// 版权所有2011 Go作者。版权所有。
// 此源代码的使用受BSD样式的约束
// 可以在许可证文件中找到的许可证。

// mkalldocs.sh生成的代码；不要编辑。
// 编辑其他文件中的文档，然后重新运行mkalldocs.sh生成此文档。

// Go是管理Go源代码的工具。
// None
// 用法：
// None
// 转到<命令>[参数]
// None
// 这些命令是：
// None
// 启动一个bug报告
// 构建编译包和依赖项
// 清除删除对象文件和缓存文件
// 文件显示包或符号的文档
// 环境打印围棋环境信息
// 修复更新包以使用新API
// fmt gofmt（重新格式化）包源
// 按处理源生成Go文件
// 获取将依赖项添加到当前模块并安装它们
// 安装、编译和安装软件包和依赖项
// 列出软件包或模块
// 模块维护
// 运行编译并运行Go程序
// 测试包
// 刀具运行指定的go刀具
// 版本打印Go版本
// 兽医报告包装中可能出现的错误
// None
// 有关命令的详细信息，请使用“转到帮助<命令>”。
// None
// 其他帮助主题：
// None
// 构建约束构建约束
// 构建模式构建模式
// c在Go和c之间调用
// 缓存构建和测试缓存
// 环境变量
// 文件类型文件类型
// go.mod文件
// gopath gopath环境变量
// gopath获取旧版gopath获取
// goproxy模块代理协议
// importpath导入路径语法
// 模块、模块版本等
// 模块获取模块感知go get
// 使用go.sum进行模块身份验证模块身份验证
// 包列表和模式
// 用于下载非公共代码的专用配置
// testflag测试标志
// testfunc测试函数
// vcs通过GOVCS控制版本控制
// None
// 有关该主题的更多信息，请使用“转到帮助<主题>”。
// None
// None
// 开始错误报告
// None
// 用法：
// None
// 去臭虫
// None
// Bug打开默认浏览器并启动新的Bug报告。
// 该报告包括有用的系统信息。
// None
// None
// 编译包和依赖项
// None
// 用法：
// None
// go build[-o output][build flags][packages]
// None
// Build编译由导入路径命名的包，
// 以及它们的依赖项，但它不会安装结果。
// None
// 如果要生成的参数是单个目录中的.go文件列表，
// build将它们视为指定单个包的源文件列表。
// None
// 编译包时，生成将忽略以“\u test.go”结尾的文件。
// None
// 编译单个主包时，生成会写入
// 将生成的可执行文件转换为以名称命名的输出文件
// 第一个源文件（'go build ed.go rx.go'写入'ed'或'ed.exe'）
// 或源代码目录（'go build unix/sam'写入'sam'或'sam.exe'）。
// 写入Windows可执行文件时添加“.exe”后缀。
// None
// 编译多个包或单个非主包时，
// build编译包，但丢弃生成的对象，
// 仅用于检查包是否可以生成。
// None
// o标志强制build写入生成的可执行文件或对象
// 指向指定的输出文件或目录，而不是所述的默认行为
// 在最后两段中。如果命名输出是现有目录或
// 以斜杠或反斜杠结束，然后是所有生成的可执行文件
// 将被写入该目录。
// None
// -i标志安装作为目标的依赖项的包。
// 不推荐使用-i标志。编译后的包将自动缓存。
// None
// 生成标志由生成、清除、获取、安装、列出、运行、，
// 和测试命令：
// None
// -a
// 强制重新生成已更新的包。
// -n
// 打印命令，但不要运行它们。
// -p n
// 程序的数量，如生成命令或
// 可以并行运行的测试二进制文件。
// 默认值是GOMAXPROCS，通常是可用的CPU数量。
// -比赛
// 启用数据竞争检测。
// 仅在linux/amd64、freebsd/amd64、darwin/amd64、windows/amd64、，
// linux/ppc64le和linux/arm64（仅适用于48位VMA）。
// -msan
// 启用与内存消毒器的互操作。
// 仅在linux/amd64、linux/arm64上受支持
// 并且仅使用Clang/LLVM作为主机C编译器。
// 在linux/arm64上，将使用饼图构建模式。
// -五
// 在编译包时打印包的名称。
// -工作
// 打印临时工作目录的名称并
// 退出时不要删除它。
// -x
// 打印命令。
// None
// -asmflags“[pattern=]arg list”
// 每次go tool asm调用时要传递的参数。
// -构建模式
// 要使用的构建模式。有关更多信息，请参阅“go help buildmode”。
// -编译器名称
// 要使用的编译器的名称，如在runtime.compiler（gccgo或gc）中。
// -gccgoflags'[pattern=]arg list'
// 在每次gccgo编译器/链接器调用上传递的参数。
// -gcflags“[pattern=]arg list”
// 每次go工具编译调用时要传递的参数。
// -安装后缀
// 要在包安装目录名称中使用的后缀，
// 以便将输出与默认生成分开。
// 如果使用-race标志，安装后缀将自动设置为race
// 或者，如果显式设置，则将_race附加到它。对于-msan也是如此
// 旗帜使用需要非默认编译标志的-buildmode选项
// 也有类似的效果。
// -ldflags“[pattern=]arg list”
// 每次go工具链接调用时要传递的参数。
// -链接共享
// 生成以前将链接到共享库的代码
// 使用-buildmode=shared创建。
// -mod模式
// 要使用的模块下载模式：只读、供应商或mod。
// 默认情况下，如果存在供应商目录，并且go.mod中的go版本
// 如果为1.14或更高，go命令的作用就好像设置了-mod=vendor一样。
// 否则，go命令的作用就好像设置了-mod=readonly一样。
// 请参阅https:
// -modcacherw
// 将新创建的目录以读写方式保留在模块缓存中
// 而不是使其只读。
// -modfile文件
// 在模块感知模式下，读取（并可能写入）备用go.mod
// 文件，而不是模块根目录中的文件。名为
// “go.mod”必须仍然存在才能确定模块根目录
// 目录，但它未被访问。当指定-modfile时
// 还使用备用go.sum文件：其路径从
// -通过修剪“.mod”扩展名并附加“.sum”来标记modfile。
// -覆盖文件
// 读取为构建操作提供覆盖的JSON配置文件。
// 该文件是一个JSON结构，带有一个名为“Replace”的字段，该字段
// 将每个磁盘文件路径（字符串）映射到其备份文件路径，以便
// 构建将像磁盘文件路径与内容一起存在一样运行
// 由备份文件路径给定，或者好像磁盘文件路径没有
// 如果其备份文件路径为空，则存在。支持-overlay标志
// 有一些限制：重要的是，cgo文件包含在
// include path必须与Go包位于同一目录中
// 当二进制文件和测试被删除时，将不会显示包含自和覆盖
// 分别运行go run和go test。
// -pkgdir目录
// 从dir而不是通常的位置安装和加载所有软件包。
// 例如，使用非标准配置构建时，
// 使用-pkgdir将生成的包保存在单独的位置。
// -标签，标签，列表
// 一个逗号分隔的构建标签列表，以考虑在
// 建筑有关生成标记的详细信息，请参见的说明
// go/build包文档中的构建约束。
// （Go的早期版本使用空格分隔的列表
// 已弃用，但仍能识别。）
// -trimpath
// 从生成的可执行文件中删除所有文件系统路径。
// 记录的文件名不是绝对文件系统路径，而是
// 将以“go”（对于标准库）开头，
// 还是模块path@version（使用模块时），
// 或普通导入路径（使用GOPATH时）。
// -toolexec'cmd args'
// 用于调用工具链程序（如vet和asm）的程序。
// 例如，不运行asm，而是运行go命令
// 'cmd args/path/to/asm<asm的参数>'。
// 将设置TOOLEXEC_IMPORTPATH环境变量，
// 为正在生成的包匹配'go list-f{{.ImportPath}'。
// None
// -asmlags、-gccgolfags、-gcflags和-ldflags标志接受
// 要传递给基础工具的以空格分隔的参数列表
// 在构建过程中。要在列表中的元素中嵌入空格，请环绕
// 它可以用单引号或双引号表示。参数列表可能是
// 前面有一个包模式和一个等号，用于限制
// 使用该参数列表来构建匹配的包
// 该模式（请参阅“go help packages”了解软件包的描述
// 模式）。如果没有模式，参数列表仅适用于
// 在命令行上命名的包。这些标志可以重复
// 使用不同的模式，以便为
// 不同的套装。如果包与中给出的模式匹配
// 多个标志，命令行上的最新匹配项获胜。
// 例如，“go build-gcflags=-S fmt”打印反汇编
// 仅适用于包fmt，而'go build-gcflags=all=-S fmt'
// 打印fmt及其所有依赖项的反汇编。
// None
// 有关指定包的详细信息，请参阅“转到帮助包”。
// 有关安装包和二进制文件的详细信息，
// 运行“go help gopath”。
// 有关在Go和C/C++之间调用的更多信息，请运行“Go help C”。
// None
// 注意：Build遵守某些约定，如所述
// 通过“go help gopath”。并非所有项目都能遵循这些惯例，
// 然而具有自己的约定或使用
// 单独的软件构建系统可以选择使用较低级别的
// 调用诸如“go tool compile”和“go tool link”以避免
// 构建工具的一些开销和设计决策。
// None
// 另请参见：安装、获取、清理。
// None
// None
// 删除对象文件和缓存文件
// None
// 用法：
// None
// 清除[清除标志][生成标志][包]
// None
// 清除从包源目录中删除对象文件。
// go命令在临时目录中生成大多数对象，
// 所以GoClean主要关注的是其他人留下的对象文件
// 工具或手动调用go build。
// None
// 如果给定了包参数或设置了-i或-r标志，
// “清除”将从每个
// 与导入路径对应的源目录：
// None
// _obj/旧对象目录，Makefiles左侧
// _测试/旧测试目录，Makefiles左侧
// _testmain.go旧gotest文件，Makefiles左侧
// test.out Makefiles留下的旧测试日志
// build.out旧测试日志，从Makefiles留下
// *[568ao]对象文件，Makefiles左侧
// None
// 从go生成目录（.exe）
// 目录测试（.exe）来自go测试-c
// go build MAINFILE.go中的MAINFILE（.exe）
// *.那么从SWIG
// None
// 在列表中，DIR表示
// 目录，MAINFILE是任何Go源的基本名称
// 生成时未包含的目录中的文件
// 包裹。
// None
// -i标志会导致clean删除相应的已安装组件
// 存档或二进制文件（go install将创建的内容）。
// None
// -n标志使clean打印它将执行的remove命令，
// 但不要运行它们。
// None
// -r标志使clean递归地应用于所有
// 由导入路径命名的包的依赖项。
// None
// -x标志使clean在执行删除命令时打印这些命令。
// None
// -cache标志导致clean删除整个go-build缓存。
// None
// -testcache标志会导致clean中的所有测试结果过期
// 去建立缓存。
// None
// -modcache标志导致clean删除整个模块
// 下载缓存，包括版本控制的未打包源代码
// 依赖关系。
// None
// 有关生成标志的更多信息，请参阅“转到帮助生成”。
// None
// 有关指定包的详细信息，请参阅“转到帮助包”。
// None
// None
// 显示包或符号的文档
// None
// 用法：
// None
// go doc[doc flags][package |[package.]symbol[.methodOrField]]
// None
// Doc打印与其标识的项目相关联的文档注释
// 参数（包、常量、func、类型、变量、方法或结构字段）
// 然后是“下”每个第一级项目的一行摘要
// 该项（包的包级声明、类型的方法、，
// 等等）。
// None
// Doc接受零、一或两个参数。
// None
// 没有参数，也就是说，当作为
// None
// 医生
// None
// 它打印当前目录中包的包文档。
// 如果包是命令（包主），则导出包的符号
// 除非提供了-cmd标志，否则将从演示文稿中删除。
// None
// 当使用一个参数运行时，该参数被视为Go语法，如
// 要记录的项目的表示。参数的选择取决于
// 关于GOROOT和GOPATH中安装的内容以及参数的形式，
// 这是其中一个示意图：
// None
// go doc<pkg>
// 转到文档<sym>[.<methodOrField>]
// go doc[<pkg>]<sym>[.<methodOrField>]
// go doc[<pkg>][<sym>]<methodOrField>
// None
// 此列表中与参数匹配的第一项是其文档
// 是印刷的。（参见下面的示例。）但是，如果参数以大写字母开头
// 字母假定它标识当前目录中的符号或方法。
// None
// 对于软件包，扫描顺序按广度优先顺序确定。
// 也就是说，提供的包是与搜索匹配且最接近的包
// 词根和词汇首先在层次结构的层次上。这棵树是
// 始终在GOPATH之前扫描其全部内容。
// None
// 如果没有指定或匹配的包，则当前
// 目录被选中，所以“GoDocFoo”显示了中符号Foo的文档
// 当前包。
// None
// 包路径必须是限定路径或正确的后缀
// 路径go工具通常的包机制不适用：包路径
// 像这样的元素。和不由go doc实现。
// None
// 当使用两个参数运行时，第一个参数必须是完整的包路径（而不仅仅是
// 后缀），第二个是符号，或带有方法或结构字段的符号。
// 这类似于godoc接受的语法：
// None
// go doc<pkg><sym>[.<methodOrField>]
// None
// 在所有形式中，当匹配符号时，参数中的小写字母将匹配
// 任何一种情况下，但大写字母完全匹配。这意味着可能有
// 如果具有不同的符号，则包中小写参数的多个匹配项
// 不同的情况。如果出现这种情况，将打印所有匹配项的文档。
// None
// 示例：
// 医生
// 显示当前包的文档。
// 去福博士
// 显示当前包中的Foo文档。
// （Foo以大写字母开头，因此不能匹配
// 包路径。）
// go文档编码/json
// 显示encoding/json包的文档。
// go doc json
// 编码/json的简写。
// go doc json.Number（或go doc json.Number）
// 显示json.Number的文档和方法摘要。
// go doc json.Number.Int64（或go doc json.Number.Int64）
// 显示json.Number的Int64方法的文档。
// go doc cmd/doc
// 显示doc命令的包文档。
// go doc-cmd cmd/doc
// 在doc命令中显示包文档和导出的符号。
// go doc template.new
// 显示html/模板新功能的文档。
// （html/模板在词汇上位于文本/模板之前）
// go doc text/template.new#一个参数
// 显示文本/模板新功能的文档。
// go doc文本/模板新建#两个参数
// 显示文本/模板新功能的文档。
// None
// 至少在当前树中，这些调用都打印
// json.Decoder解码方法的文档：
// None
// go doc json.Decoder.Decode
// go doc json.decoder.decode
// go doc json.decode
// cd go/src/encoding/json；去文件解码
// None
// 旗帜：
// -全部
// 显示包的所有文档。
// -c
// 匹配符号时，请尊重大小写。
// -指令
// 将命令（包main）视为常规包。
// 否则，将隐藏包main的导出符号
// 显示包的顶级文档时。
// -短
// 每个符号用一行表示。
// -src
// 显示符号的完整源代码。这将
// 显示其声明的完整Go源，并
// 定义，例如函数定义（包括
// 主体），类型声明或封闭常量
// 块因此，输出可能包括未报告的数据
// 细节。
// -u
// 显示未报告和导出的文档
// 符号、方法和字段。
// None
// None
// 打印围棋环境信息
// None
// 用法：
// None
// go env[-json][u][w][var…]
// None
// Env打印Go环境信息。
// None
// 默认情况下，env将信息打印为shell脚本
// （在Windows上，为批处理文件）。如果一个或多个变量
// 名称作为参数提供，env打印
// 每个命名变量在其自己的行上。
// None
// -json标志以json格式打印环境
// 而不是作为shell脚本。
// None
// -u标志需要一个或多个参数并取消设置
// 命名环境变量的默认设置，
// 如果其中一个已设置为“go env-w”。
// None
// -w标志需要一个或多个
// 表单名称=值并更改默认设置
// 将命名的环境变量设置为给定值。
// None
// 有关环境变量的更多信息，请参阅“go help environment”。
// None
// None
// 更新包以使用新的API
// None
// 用法：
// None
// 去修理[包裹]
// None
// Fix对导入路径命名的包运行Go Fix命令。
// None
// 有关修复的更多信息，请参阅“go doc cmd/fix”。
// 有关指定包的详细信息，请参阅“转到帮助包”。
// None
// 要使用特定选项运行修复程序，请运行“go tool fix”。
// None
// 另见：去fmt，去兽医。
// None
// None
// Gofmt（重新格式化）包源
// None
// 用法：
// None
// go fmt[-n][x][packages]
// None
// Fmt在名为的包上运行命令“gofmt-l-w”
// 通过导入路径。它打印被修改文件的名称。
// None
// 有关gofmt的更多信息，请参阅“go doc cmd/gofmt”。
// 有关指定包的详细信息，请参阅“转到帮助包”。
// None
// -n标志打印将要执行的命令。
// -x标志在命令执行时打印命令。
// None
// -mod标志的值设置了哪个模块下载模式
// 要使用：只读或供应商。有关更多信息，请参阅“go帮助模块”。
// None
// 要使用特定选项运行gofmt，请运行gofmt本身。
// None
// 另见：去修理，去检查。
// None
// None
// 通过处理源代码生成Go文件
// None
// 用法：
// None
// 转到生成[-run regexp][n][v][x][build flags][file.go…| packages]
// None
// 生成运行现有系统中由指令描述的命令
// 文件夹。这些命令可以运行任何进程，但目的是
// 创建或更新Go源文件。
// None
// Go generate从不通过Go build、Go get、Go test自动运行，
// 等等它必须显式运行。
// None
// Go generate扫描文件中的指令，这些指令是
// 形式,，
// None
// None
// None
// （注意：无前导空格和中无空格）
// 要运行的生成器，对应于可执行文件
// 可以在本地运行。它必须位于shell路径中
// （gofmt）、完全限定路径（/usr/you/bin/mytool）或
// 命令别名，如下所述。
// None
// 请注意，go generate不会解析文件，因此
// 将处理注释或多行字符串中的like指令
// 作为指示。
// None
// 指令的参数是空格分隔的标记或
// 作为单个字符串传递给生成器的双引号字符串
// 运行时的参数。
// None
// 带引号的字符串使用Go语法，并在执行前进行评估；A.
// 带引号的字符串作为单个参数显示给生成器。
// None
// 向人类和机床传达生成的代码，
// 生成的源应具有与以下内容匹配的行
// 正则表达式（Go语法）：
// None
// ^
// None
// 该行必须出现在第一个非注释、非空白的前面
// 文件中的文本。
// None
// Go generate在运行生成器时设置多个变量：
// None
// $GOARCH
// 执行架构（arm、amd64等）
// $GOOS
// 执行操作系统（linux、windows等）
// $GOFILE
// 文件的基本名称。
// $GOLINE
// 源文件中指令的行号。
// $GOPACKAGE
// 包含指令的文件包的名称。
// 美元
// 美元符号。
// None
// 除变量替换和带引号的字符串求值外，无
// 对命令执行特殊处理，如“globbing”
// 线
// None
// 作为运行命令之前的最后一步，任何
// 具有字母数字名称的环境变量，例如$GOFILE或
// $HOME，在整个命令行中展开。的语法
// 变量扩展在所有操作系统上都是$NAME。由于
// 计算顺序，变量展开，甚至在内部引用
// 串。如果未设置变量名，$NAME将扩展到
// 空字符串。
// None
// 形式的指令，
// None
// None
// None
// 仅为此源文件的其余部分指定
// 字符串xxx表示由参数标识的命令。这
// 可用于创建别名或处理多字生成器。
// 例如
// None
// None
// None
// 指定命令“foo”表示生成器
// “去工具屋”。
// None
// 按照命令行中给定的顺序生成进程包，
// 一次一个。如果命令行列出单个目录中的.go文件，
// 它们被视为一个单独的包裹。在包中，生成进程
// 包中的源文件按文件名顺序，一次一个。在内部
// 在源文件中，generate按生成器的显示顺序运行生成器
// 在文件中，一次一个。go generate工具还设置构建
// 标记“generate”，以便go generate可以检查但忽略文件
// 在构建期间。
// None
// 对于具有无效代码的包，仅生成具有
// 有效的包子句。
// None
// 如果任何生成器返回错误退出状态，“go generate”将跳过
// 该包的所有进一步处理。
// None
// 生成器在包的源目录中运行。
// None
// Go generate接受一个特定标志：
// None
// -run=“”
// 如果非空，则指定要选择的正则表达式
// 其完整原始源文本（不包括
// 任何尾随空格和最终换行符）都与
// 表示
// None
// 它还接受标准构建标志，包括-v、-n和-x。
// v标志按原样打印包和文件的名称
// 处理。
// -n标志打印将要执行的命令。
// -x标志在命令执行时打印命令。
// None
// 有关生成标志的更多信息，请参阅“转到帮助生成”。
// None
// 有关指定包的详细信息，请参阅“转到帮助包”。
// None
// None
// 将依赖项添加到当前模块并安装它们
// None
// 用法：
// None
// 获取[-d][t][u][v][build flags][packages]
// None
// Get将其命令行参数解析为特定模块版本的包，
// 更新go.mod以需要这些版本，将源代码下载到
// 模块缓存，然后构建并安装命名包。
// None
// 要为包添加依赖项或将其升级到最新版本，请执行以下操作：
// None
// 去获取example.com/pkg
// None
// 要将程序包升级或降级到特定版本，请执行以下操作：
// None
// 去获取example.com/pkg@v1.2.3
// None
// 要删除对模块的依赖关系并降级需要它的模块，请执行以下操作：
// None
// 去获取example.com/mod@none
// None
// 请参阅https:
// None
// “go install”命令可用于生成和安装软件包。当
// 已指定版本，“go install”在模块感知模式下运行并忽略
// 当前目录中的go.mod文件。例如：
// None
// 转到install example.com/pkg@v1.2.3
// 转到install example.com/pkg@latest
// None
// 请参阅“go help install”或https：
// None
// 除了生成标志（在“go help build”中列出）之外，“go get”接受
// 下面的旗帜。
// None
// -T标志指示要考虑构建测试所需的模块。
// 在命令行上指定的包。
// None
// u标志指示get更新提供依赖项的模块
// 在命令行上命名以使用较新的次要或修补程序的包的数量
// 在可用时发布。
// None
// -u=patch标志（不是-u patch）也指示get更新依赖项，
// 但将默认设置更改为选择修补程序版本。
// None
// 当-t和-u标志一起使用时，get将更新
// 测试依赖关系。
// None
// -d标志指示get不构建或安装包。只会
// 更新go.mod并下载构建包所需的源代码。
// None
// 不推荐使用get构建和安装包。在未来的版本中，
// 默认情况下，-d标志将启用，“go get”将仅用于
// 调整当前模块的依赖项。要使用安装包，请执行以下操作：
// 来自当前模块的依赖项，请使用“go install”。安装软件包
// 忽略当前模块，使用带有@version后缀的“go install”，如
// 每次争论后加上“@latest”。
// None
// 有关模块的更多信息，请参阅https:
// None
// 有关指定包的详细信息，请参阅“转到帮助包”。
// None
// 本文描述了get使用模块管理源代码的行为
// 代码和依赖项。如果改为go命令在GOPATH中运行
// 模式下，get的标志和效果的细节会发生变化，“go help get”也会发生变化。
// 请参阅“go help gopath get”。
// None
// 另请参见：go build、go install、go clean、go mod。
// None
// None
// 编译和安装软件包和依赖项
// None
// 用法：
// None
// 转到安装[build flags][packages]
// None
// Install编译并安装由导入路径命名的包。
// None
// 可执行文件安装在GOBIN环境命名的目录中
// 变量，默认为$GOPATH/bin或$HOME/go/bin（如果GOPATH
// 未设置环境变量。$GOROOT中的可执行文件
// 安装在$GOROOT/bin或$GOTOOLDIR而不是$GOBIN中。
// None
// 如果参数有版本后缀（如@latest或@v1.0.0），“go install”
// 在模块感知模式下生成包，忽略当前
// 目录或任何父目录（如果有）。这对我们来说很有用
// 在不影响主模块依赖关系的情况下安装可执行文件。
// 为了消除关于在构建中使用哪些模块版本的不确定性
// 参数必须满足以下约束：
// None
// -参数必须是包路径或包模式（带有“…”通配符）。
// 它们不能是标准包（如fmt）、元模式（std、cmd、，
// 全部），或相对或绝对文件路径。
// None
// -所有参数必须具有相同的版本后缀。不支持不同的查询
// 允许，即使它们引用相同的版本。
// None
// -所有参数都必须引用同一模块中同一版本的包。
// None
// -没有模块被视为“主”模块。如果模块包含
// 命令行上命名的包有一个go.mod文件，它不能包含
// 将导致对其进行解释的指令（替换和排除）
// 与主模块不同。该模块不得要求
// 自我的更高版本。
// None
// -包路径参数必须引用主包。模式参数
// 将只匹配主包。
// None
// 如果参数没有版本后缀，“go install”可能会在中运行
// 模块感知模式或GOPATH模式，取决于GO111模块环境
// 变量和go.mod文件的存在。有关详细信息，请参阅“go帮助模块”。
// 如果启用了模块感知模式，“go install”将在主服务器的上下文中运行
// 单元
// None
// 禁用模块感知模式时，将在中安装其他软件包
// 目录$GOPATH/pkg/$GOOS_uu$GOARCH。启用模块感知模式时，
// 其他软件包已生成并缓存，但未安装。
// None
// -i标志还安装命名包的依赖项。
// 不推荐使用-i标志。编译后的包将自动缓存。
// None
// 有关构建标志的更多信息，请参阅“go help build”。
// 有关指定包的详细信息，请参阅“转到帮助包”。
// None
// 另见：去建造，去获取，去清理。
// None
// None
// 列出软件包或模块
// None
// 用法：
// None
// go list[-f格式][-json][m][list flags][build flags][packages]
// None
// 列表列出命名的包，每行一个。
// 最常用的标志是-f和-json，它们控制表单
// 为每个包装打印的输出的。其他列表标志，记录如下，
// 控制更具体的细节。
// None
// 默认输出显示包导入路径：
// None
// 字节
// 编码/json
// github.com/gorilla/mux
// golang.org/x/net/html
// None
// -f标志使用
// 包模板的语法。默认输出是等效的
// 到-f'{.ImportPath}}'。传递给模板的结构是：
// None
// 类型包结构{
// 目录字符串
// 输入路径字符串
// 重要推荐字符串
// 名称字符串
// 文档字符串
// 目标字符串
// Shlib字符串
// 戈罗特布尔
// 标准布尔
// 陈腐的布尔
// 过时原因字符串
// 根字符串
// ConflictDir字符串
// 二元纯布尔
// 福斯特串
// 导出字符串
// BuildID字符串
// 模块*模块
// 匹配[]字符串
// 德波恩布尔
// None
// None
// GoFiles[]字符串
// CgoFiles[]字符串
// 编译文件[]字符串
// IgnoredGoFiles[]字符串
// IgnoredOtherFiles[]字符串
// CFiles[]字符串
// CXXFiles[]字符串
// MFiles[]字符串
// HFiles[]字符串
// FFiles[]字符串
// SFiles[]字符串
// SwigFiles[]字符串
// SwigCXXFiles[]字符串
// SysoFiles[]字符串
// TestGoFiles[]字符串
// XTestGoFiles[]字符串
// None
// None
// 嵌入模式[]字符串
// 嵌入文件[]字符串
// TestEmbedPatterns[]字符串
// TestEmbedFiles[]字符串
// XTestEmbedPatterns[]字符串
// XTestEmbedFiles[]字符串
// None
// None
// CgoCFLAGS[]字符串
// cgocpflags[]字符串
// CgoCXXFLAGS[]字符串
// CgoFFLAGS[]字符串
// CgoLDFLAGS[]字符串
// CgoPkgConfig[]字符串
// None
// None
// 导入[]字符串
// ImportMap[字符串]字符串
// Deps[]字符串
// TestImports[]字符串
// XTestImports[]字符串
// None
// None
// 不完全布尔
// 错误*PackageError
// deprorrors[]*程序包错误
// }
// None
// 存储在供应商目录中的程序包报告一个包含
// 供应商目录的路径（例如，“d/vendor/p”而不是“p”），
// 这样，ImportPath就可以唯一地标识包的给定副本。
// 导入、DEP、TestImports和XTestImports列表也包含这些
// 扩展的导入路径。有关供应商的更多信息，请参见golang.org/s/go15vendor。
// None
// 错误信息（如果有）为
// None
// 类型PackageError结构{
// ImportStack[]字符串
// Pos字符串
// 错误字符串
// }
// None
// 模块信息是讨论中定义的模块结构
// 下面的列表-m。
// None
// 模板函数“join”调用strings.join。
// None
// 模板函数“context”返回生成上下文，定义为：
// None
// 类型上下文结构{
// 球门绳
// 粘绳
// 根弦
// GOPATH字符串
// cgoenablebool
// 使用所有文件布尔
// 编译字符串
// BuildTags[]字符串
// 工具标签[]字符串
// ReleaseTags[]字符串
// 安装后缀字符串
// }
// None
// 有关这些字段含义的更多信息，请参阅文档
// 用于go/build包的上下文类型。
// None
// -json标志使包数据以json格式打印
// 而不是使用模板格式。
// None
// -compiled标志使列表将compiledProfiles设置为Go源
// 提交给编译器的文件。通常这意味着它会重复
// GoFiles中列出的文件，然后还添加生成的Go代码
// 通过处理cgofile和swigfile。导入列表包含
// 从GOFILE和CompiledProfiles导入的所有文件的联合。
// None
// -deps标志使列表不仅遍历指定的包
// 还有他们的所有依赖关系。它首先对他们进行深度访问
// 遍历，使包仅在其所有依赖项之后列出。
// 命令行中未明确列出的包将具有depoly属性
// 字段设置为true。
// None
// -e标志改变了对错误包的处理，这些错误包
// 找不到或格式不正确。默认情况下，list命令
// 将每个错误包的错误打印为标准错误，然后
// 在通常的打印过程中忽略包装。
// 使用-e标志时，list命令从不将错误打印到标准
// 错误，而是使用通常的
// 印刷错误的包将有一个非空的ImportPath和
// 非零错误字段；其他信息可能缺失，也可能不缺失
// （归零）。
// None
// -export标志使列表将导出字段设置为
// 包含给定包的最新导出信息的文件。
// None
// -find标志使列表标识已命名的包，但不标识已命名的包
// 解决它们的依赖关系：导入和Deps列表将为空。
// None
// -test标志使列表不仅报告命名的包
// 还包括它们的测试二进制文件（用于带有测试的包），以传递给
// 源代码分析工具准确地描述了测试二进制文件的构造方式。
// 测试二进制文件的报告导入路径是的导入路径
// 软件包后面跟一个“.test”后缀，如“math/rand.test”。
// 在构建测试时，有时需要重建某些
// 特定于该测试的依赖项（最常见的是被测试的
// 软件包本身）。重新编译的包的报告导入路径
// 对于特定的测试，二进制文件后面跟一个空格和
// 括号中的测试二进制文件，如“math/rand[math/rand.test]”
// 或“regexp[sort.test]”。ForTest字段也设置为名称
// 正在测试的包的名称（“数学/兰德”或“排序”在前面的
// 示例）。
// None
// Dir、Target、Shlib、Root、ConflictDir和导出文件路径
// 都是绝对路径。
// None
// 默认情况下，列表GoFiles、CgoFiles等包含目录中的文件名
// （即，相对于Dir的路径，而不是绝对路径）。
// 使用-compiled和-test标志时添加的生成文件
// 是指生成的Go源文件的缓存副本的绝对路径。
// 虽然它们是Go源文件，但路径可能不会以“.Go”结尾。
// None
// -m标志使list列出模块而不是包。
// None
// 列出模块时，-f标志仍然指定格式模板
// 应用于Go结构，但现在是模块结构：
// None
// 类型模块结构{
// 路径字符串
// 版本字符串
// 版本[]字符串
// 更换*模块
// 时间，时间，时间
// 更新*模块
// 主布尔
// 间接布尔
// 目录字符串
// 戈莫德弦
// 政府字符串
// 缩绳
// 错误*模块错误
// }
// None
// 类型ModuleError结构{
// 错误字符串
// }
// None
// 如果
// 模块在模块缓存中，或者如果使用了-modfile标志。
// None
// 默认输出是打印模块路径，然后
// 有关版本和更换件（如有）的信息。
// 例如，“go list-m all”可能会打印：
// None
// 我的/主/模块
// golang.org/x/text v0.3.0=>/tmp/text
// rsc.io/pdf v0.1.1
// None
// 模块结构有一个字符串方法来格式化此
// 输出行，使默认格式等效
// 到-f'{.String}}'。
// None
// 请注意，更换模块后，其“更换”字段
// 描述替换模块，其Dir字段设置为
// 替换的源代码（如果存在）。（即，如果更换
// 为非nil，则Dir设置为Replace.Dir，无法访问
// 替换的源代码。）
// None
// -u标志添加有关可用升级的信息。
// 当给定模块的最新版本比
// 当前列表-u设置模块的更新字段
// 获取有关较新模块的信息。列表-u也将被设置
// 如果当前版本已收回，则显示模块的收回字段。
// 模块的String方法指示通过以下方式进行的可用升级：
// 在当前版本后的括号中格式化较新版本。
// 如果版本被收回，字符串“（收回）”将跟随它。
// 例如，“go list-m-u all”可能会打印：
// None
// 我的/主/模块
// golang.org/x/text v0.3.0[v0.4.0]=>/tmp/text
// rsc.io/pdf v0.1.1（收回）[v0.1.2]
// None
// （对于工具，“go list-m-u-json all”可能更便于解析。）
// None
// -versions标志使列表设置模块的版本字段
// 该模块的所有已知版本的列表，根据
// 到语义版本控制，从早到晚。标志也会改变
// 显示模块路径的默认输出格式，后跟
// 以空格分隔的版本列表。
// None
// -retracted标志使列表报告有关retracted的信息
// 模块版本。当-retracted与-f或-json一起使用时，retracted
// 字段将设置为一个字符串，解释版本被收回的原因。
// 该字符串取自
// 模块的go.mod文件。当-retracted与-versions一起使用时，retracted
// 版本与未跟踪的版本一起列出。这架飞机收回了
// 标志可以与-m一起使用，也可以不与-m一起使用。
// None
// list-m的参数被解释为模块列表，而不是包。
// 主模块是包含当前目录的模块。
// 活动模块是主模块及其依赖项。
// 如果没有参数，list-m将显示主模块。
// 对于参数，list-m显示由参数指定的模块。
// 任何活动模块均可通过其模块路径指定。
// 特殊模式“all”指定所有活动模块，首先是主模块
// 然后是按模块路径排序的依赖项。
// 包含“…”的模式指定其
// 模块路径与模式匹配。
// 对表单的查询path@version指定该查询的结果，
// 不限于有源模块。
// 有关模块查询的更多信息，请参阅“转到帮助模块”。
// None
// 模板函数“module”采用单个字符串参数
// 必须是模块路径或查询，并返回指定的
// 模块作为模块结构。如果发生错误，结果将是错误的
// 必须是具有非零错误字段的模块结构。
// None
// 有关生成标志的更多信息，请参阅“转到帮助生成”。
// None
// 有关指定包的详细信息，请参阅“转到帮助包”。
// None
// 有关模块的更多信息，请参阅https:
// None
// None
// 模块维护
// None
// Go mod提供对模块操作的访问。
// None
// 请注意，所有go命令都内置了对模块的支持，
// 不仅仅是“去改装”。例如，日常添加、删除、升级、，
// 应该使用“go-get”对依赖项进行降级。
// 有关模块功能的概述，请参阅“转到帮助模块”。
// None
// 用法：
// None
// 转到mod<command>[参数]
// None
// 这些命令是：
// None
// 将下载模块下载到本地缓存
// 从工具或脚本编辑go.mod
// 图形打印模块需求图
// 初始化当前目录中的新模块
// 整理添加丢失的模块并删除未使用的模块
// 供应商制作依赖项的供应商副本
// 验证依赖项是否具有预期的内容
// 为什么要解释为什么需要软件包或模块
// None
// 有关命令的更多信息，请使用“go help mod<command>”。
// None
// 将模块下载到本地缓存
// None
// 用法：
// None
// go mod下载[-x][-json][modules]
// None
// 下载命名模块，可以是模块模式
// 窗体的主模块或模块查询的依赖项path@version.
// 如果没有参数，下载将应用于主模块的所有依赖项
// （相当于“go mod下载全部”）。
// None
// 正常运行期间，go命令将根据需要自动下载模块
// 处决“go mod download”命令主要用于预填充
// 本地缓存或用于计算Go模块代理的答案。
// None
// 默认情况下，下载不会将任何内容写入标准输出。它可以打印进度
// 将消息和错误更改为标准错误。
// None
// -json标志使download打印json对象序列
// 至标准输出，描述每个下载模块（或故障），
// 对应于此Go结构：
// None
// 类型模块结构{
// 路径字符串
// 版本字符串
// 错误字符串
// 信息字符串
// 戈莫德弦
// 拉链
// 目录字符串
// 总和字符串
// GoModSum字符串
// }
// None
// -x标志使download打印下载执行的命令。
// None
// 请参阅https:
// None
// 请参阅https:
// None
// None
// 从工具或脚本编辑go.mod
// None
// 用法：
// None
// go mod edit[编辑标志][fmt |-print |-json][go.mod]
// None
// Edit提供用于编辑go.mod的命令行界面，
// 主要由工具或脚本使用。它只显示go.mod；
// 它不查找有关所涉及模块的信息。
// 默认情况下，edit读取和写入主模块的go.mod文件，
// 但是，可以在编辑标志之后指定不同的目标文件。
// None
// 编辑标志指定一系列编辑操作。
// None
// -fmt标志重新格式化go.mod文件，而不进行其他更改。
// 使用或修改的任何其他修改也暗示了这种重新格式化
// 重写go.mod文件。唯一需要此标志的时间是如果没有其他标志
// 指定标志，如“go mod edit-fmt”中所示。
// None
// -module标志更改模块的路径（go.mod文件的模块行）。
// None
// 要求=path@versionand-droprequire=路径标志
// 在给定模块路径和版本上添加和删除需求。
// 请注意，-require将覆盖路径上的任何现有要求。
// 这些标志主要用于理解模块图的工具。
// 用户应该更喜欢“go-get”path@version或者去拿path@none',
// 根据需要进行其他go.mod调整，以满足
// 其他模块施加的约束。
// None
// 排除=path@version和-排除=path@version旗帜
// 添加和删除给定模块路径和版本的排除。
// 请注意-exclude=path@version如果排除已存在，则为无操作。
// None
// -replace=old[@v]=new[@v]标志用于添加给定
// 模块路径和版本对。如果@v在old@v省略，a
// 添加了左侧无版本的替换，适用于
// 到旧模块路径的所有版本。如果@v在new@v省略了，
// 新路径应该是本地模块根目录，而不是模块
// 路径请注意，-replace会覆盖旧[@v]的任何冗余替换，
// 因此省略@v将删除特定版本的现有替换。
// None
// -dropreplace=old[@v]标志会删除给定
// 模块路径和版本对。如果省略@v，则更换时不带
// 左侧的版本被删除。
// None
// -retract=version和-dropretract=version标志添加和删除
// 给定版本上的缩回。该版本可以是单个版本
// 类似于“v1.2.3”或类似于“[v1.1.0，v1.1.9]”的闭合区间。注意
// -收回=如果收回已经存在，则版本为无操作。
// None
// -require、-droprequire、-exclude、-dropexclude、-replace、，
// -dropreplace、-retract和-dropretract编辑标志可以重复，
// 并按照给定的顺序应用更改。
// None
// -go=version标志设置预期的go语言版本。
// None
// -print标志以文本格式打印最终go.mod，而不是
// 将其写回go.mod。
// None
// -json标志以json格式打印最终的go.mod文件，而不是
// 将其写回go.mod。JSON输出对应于以下Go类型：
// None
// 类型模块结构{
// 路径字符串
// 版本字符串
// }
// None
// 类型GoMod结构{
// 模块ModPath
// 挂线
// 要求
// 排除[]模块
// 替换[]替换
// 收回
// }
// None
// 类型ModPath结构{
// 路径字符串
// 弃用字符串
// }
// None
// 类型要求结构{
// 路径字符串
// 版本字符串
// 间接布尔
// }
// None
// 类型替换结构{
// 旧模块
// 新模块
// }
// None
// 类型收回结构{
// 低弦
// 高弦
// 基本原理字符串
// }
// None
// 表示单个版本（非间隔）的收回条目将具有
// “低”和“高”字段设置为相同的值。
// None
// 请注意，这只描述go.mod文件本身，而不描述其他模块
// 间接提及。对于构建可用的全套模块，
// 使用'go list-m-json all'。
// None
// 请参阅https:
// None
// None
// 打印模块需求图
// None
// 用法：
// None
// go mod图形[-go=版本]
// None
// 图打印模块需求图（应用替换）
// 以文本形式。输出中的每一行都有两个空格分隔的字段：一个模块
// 以及它的一个要求。每个模块都被标识为表单的字符串
// path@version，但主模块除外，它没有@version后缀。
// None
// -go标志使graph报告模块加载的模块图
// 给定Go版本，而不是“Go”指令指示的版本
// 在go.mod文件中。
// None
// 请参阅https:
// None
// None
// 在当前目录中初始化新模块
// None
// 用法：
// None
// go mod init[模块路径]
// None
// Init在当前目录中初始化并写入一个新的go.mod文件
// 在当前目录下创建新模块的效果。go.mod文件
// 不能已经存在。
// None
// Init接受一个可选参数，即新模块的模块路径。如果
// 忽略模块路径参数，init将尝试推断模块路径
// 在.go文件、供应商工具配置文件（如
// lock）和当前目录（如果在GOPATH中）。
// None
// 如果存在供应商工具的配置文件，init将尝试
// 从it导入模块需求。
// None
// 请参阅https:
// None
// None
// 添加缺少的模块并删除未使用的模块
// None
// 用法：
// None
// go mod tidy[-e][-v][-go=版本][-compat=版本]
// None
// Tidy确保go.mod与模块中的源代码匹配。
// 它添加了构建当前模块所需的所有缺失模块
// 包和依赖项，并删除
// 不要提供任何相关的软件包。它还会添加任何缺少的条目
// 求和并删除任何不必要的项。
// None
// -v标志导致tidy打印有关已删除模块的信息
// 标准误差。
// None
// -e标志会导致tidy在出现错误的情况下尝试继续
// 加载包时遇到错误。
// None
// -go标志导致tidy更新go.mod中的'go'指令
// 文件转换为给定版本，这可能会更改哪些模块依赖项
// 作为明确要求保留在go.mod文件中。
// （Go版本1.17和更高版本保留了更多要求，以便
// 支持延迟模块加载。）
// None
// -compat标志保留了
// 指示的主要go释放中的“go”命令成功加载
// 如果该版本的
// “go”命令将从其他模块加载任何导入的包
// 版本默认情况下，tidy的行为就像将-compat标志设置为
// go.mod中“go”指令指示的版本之前的版本
// 文件
// None
// 请参阅https:
// None
// None
// 制作依赖项的副本
// None
// 用法：
// None
// go mod供应商[-e][-v]
// None
// 供应商重置主模块的供应商目录以包含所有软件包
// 需要构建和测试所有主模块的包。
// 它不包括供应商包的测试代码。
// None
// -v标志使供应商打印供应商的名称
// 模块和软件包出现标准错误。
// None
// -e标志会导致供应商在出现错误的情况下尝试继续
// 加载包时遇到错误。
// None
// 请参阅https:
// None
// None
// 验证依赖项是否具有预期的内容
// None
// 用法：
// None
// 去核实一下
// None
// 验证是否检查当前模块的依赖项，
// 存储在本地下载的源缓存中的，尚未
// 下载后已修改。如果所有模块都未修改，
// verify打印“所有模块已验证”。否则它会报告
// 模块已更改，导致“go mod”退出，并显示
// 非零状态。
// None
// 请参阅https:
// None
// None
// 解释为什么需要软件包或模块
// None
// 用法：
// None
// 转到mod why[-m][-vendor]包。。。
// None
// 为什么在导入图中显示从主模块到的最短路径
// 列出的每个包。如果给出了-m标志，为什么要处理
// 参数作为模块列表，并查找每个模块中任何包的路径
// 模块的名称。
// None
// 默认情况下，为什么查询“go list all”匹配的包图，
// 其中包括对可访问包的测试。-vendor标志导致
// 排除依赖项测试。
// None
// 输出是一段序列，每个包或模块对应一段
// 命令行上的名称，用空行分隔。每节开始
// 带有注释行“#package”或“#module”给出目标
// 包或模块。后续行提供了通过导入的路径
// 图，每行一个包。如果程序包或模块不可用
// 从主模块引用，节将显示一个
// 括号内的注释表明了这一事实。
// None
// 例如：
// None
// $go mod why golang.org/x/text/language golang.org/x/text/encoding
// #golang.org/x/text/language
// rsc.io/quote
// rsc.io/采样器
// golang.org/x/text/language
// None
// #golang.org/x/text/encoding
// （主模块不需要golang.org/x/text/encoding包）
// $
// None
// 请参阅https:
// None
// None
// 编译并运行Go程序
// None
// 用法：
// None
// 运行[build flags][-exec xprog]包[arguments…]
// None
// Run编译并运行命名的main Go包。
// 通常，该包被指定为单个数据库中.go源文件的列表
// 目录，但也可以是导入路径、文件系统路径或模式
// 匹配单个已知包，如“go run.”或“go run my/cmd”。
// None
// 如果包参数有版本后缀（如@latest或@v1.0.0），
// “go run”以模块感知模式构建程序，忽略中的go.mod文件
// 当前目录或任何父目录（如果有）。这是有用的
// 用于在不影响主模块依赖关系的情况下运行程序。
// None
// 如果package参数没有版本后缀，“go run”可能会在中运行
// 模块感知模式或GOPATH模式，取决于GO111模块环境
// 变量和go.mod文件的存在。有关详细信息，请参阅“go帮助模块”。
// 如果启用了模块感知模式，“go run”将在主模块的上下文中运行
// 单元
// None
// 默认情况下，“go run”直接运行编译后的二进制文件：“a.out arguments…”。
// 如果给定-exec标志，“go run”将使用xprog调用二进制文件：
// “xprog a.out参数…”。
// 如果未给出-exec标志，则GOOS或GOARCH与系统不同
// 默认值，并且可以找到名为go_u$GOOS_$GOARCH_exec的程序
// 在当前搜索路径上，“go run”使用该程序调用二进制文件，
// 例如“go_js_wasm_exec a.out arguments…”。这允许执行
// 使用模拟器或其他执行方法时交叉编译的程序
// 可获得的
// None
// Run的退出状态不是已编译二进制文件的退出状态。
// None
// 有关生成标志的更多信息，请参阅“转到帮助生成”。
// 有关指定包的详细信息，请参阅“转到帮助包”。
// None
// 另请参见：go build。
// None
// None
// 测试包
// None
// 用法：
// None
// go test[生成/测试标志][包][生成/测试标志和测试二进制标志]
// None
// “Go test”自动测试由导入路径命名的包。
// 它以以下格式打印测试结果摘要：
// None
// 正常存档/tar 0.011s
// 存档失败/zip 0.022s
// 正常压缩/gzip 0.033s
// ...
// None
// 然后是每个失败包的详细输出。
// None
// “Go test”重新编译每个包以及名称匹配的任何文件
// 文件模式“*\u test.go”。
// 这些附加文件可以包含测试函数、基准函数和
// 示例函数。有关更多信息，请参阅“go help testfunc”。
// 每个列出的包都会导致执行一个单独的测试二进制文件。
// 名称以“_”（包括“_test.go”）或“.”开头的文件将被忽略。
// None
// 声明后缀为“_Test”的包的测试文件将编译为
// 分离包，然后与主测试二进制文件链接并运行。
// None
// go工具将忽略名为“testdata”的目录，使其可用
// 保存测试所需的辅助数据。
// None
// 作为构建测试二进制文件的一部分，go测试在包上运行go-vet
// 及其测试源文件，以确定重大问题。如果去看兽医
// 发现任何问题，go test报告这些问题，并且不运行测试
// 二进制的只有默认go-vet检查的高置信度子集是可用的
// 习惯于该子集是：“原子”、“bool”、“buildtags”、“errorsas”，
// “ifaceassert”、“nilfunc”、“printf”和“stringintconv”。你可以看到
// 通过“go doc cmd/vet”提供这些和其他vet测试的文档。
// 要禁用go-vet的运行，请使用-vet=off标志。
// None
// 所有测试输出和摘要行都打印到go命令的
// 标准输出，即使测试按照自己的标准打印
// 错误（go命令的标准错误保留用于打印
// 生成测试时出错。）
// None
// 在两种不同模式下进行测试运行：
// None
// 第一种模式称为本地目录模式，在执行go测试时发生
// 在没有包参数的情况下调用（例如，“go test”或“go test”）
// 测试-v'）。在此模式下，go test编译包源代码和
// 在当前目录中找到测试，然后运行生成的
// 测试二进制文件。在此模式下，将禁用缓存（如下所述）。
// 包测试完成后，go test打印一个摘要行
// 显示测试状态（“正常”或“失败”）、包名称和运行时间
// 时间
// None
// 第二种称为包列表模式，在调用go测试时发生
// 使用显式包参数（例如“go test math”、“go
// 测试。/…'，甚至“去测试”。）。在此模式下，go test编译
// 并测试命令行上列出的每个包。如果
// 包测试通过，go测试仅打印最终“ok”摘要
// 线如果包测试失败，go test将打印完整的测试输出。
// 如果使用-bench或-v标志调用，go test将打印完整的
// 即使通过包测试也要输出，以便显示
// 请求的基准测试结果或详细日志记录。包装后
// 所有列出的包的测试都完成，其输出为
// 打印，go test打印最终“失败”状态（如果有任何包测试）
// 失败了。
// None
// 仅在包列表模式下，go test缓存成功的包测试
// 结果，以避免不必要的重复运行测试。当
// 测试结果可以从缓存中恢复，go test将
// 重新显示以前的输出，而不是运行测试二进制文件
// 再一次发生这种情况时，go test打印“（缓存）”以代替
// 摘要行中的已用时间。
// None
// 缓存中匹配的规则是，运行涉及相同的
// 测试二进制文件和命令行上的标志完全来自
// “可缓存”测试标志的限制集，定义为-benchtime，-cpu，
// -列表、-parallel、-run、-short和-v。如果运行go测试有任何测试
// 或此集合之外的非测试标志，则不会缓存结果。到
// 禁用测试缓存，使用除
// 可缓存标志。显式禁用测试缓存的惯用方法
// 是使用-count=1。在包的源代码中打开文件的测试
// 根（通常为$GOPATH）或仅参考环境变量的
// 匹配文件和环境变量不变的未来运行。
// 缓存的测试结果将被视为立即执行，
// 因此，成功的包测试结果将被缓存和重用
// 不考虑-超时设置。
// None
// 除构建标志外，“go test”本身处理的标志包括：
// None
// -args
// 传递命令行的其余部分（在-args之后的所有内容）
// 对于测试二进制文件，未解释且未更改。
// 因为此标志占用命令行的其余部分，
// 包列表（如果存在）必须显示在此标志之前。
// None
// -c
// 将测试二进制文件编译为pkg.test，但不要运行它
// （其中pkg是包导入路径的最后一个元素）。
// 可以使用-o标志更改文件名。
// None
// -exec xprog
// 使用xprog运行测试二进制文件。行为与
// 在“快跑”中。有关详细信息，请参阅“go help run”。
// None
// -我
// 安装作为测试依赖项的软件包。
// 不要运行测试。
// 不推荐使用-i标志。编译后的包将自动缓存。
// None
// -json
// 将测试输出转换为适合自动处理的JSON。
// 有关编码详细信息，请参阅“go doc test2json”。
// None
// -o文件
// 将测试二进制文件编译到命名文件。
// 测试仍在运行（除非指定了-c或-i）。
// None
// 测试二进制文件还接受控制测试执行的标志；这些
// “go test”也可以访问标志。有关详细信息，请参阅“go help testflag”。
// None
// 有关生成标志的更多信息，请参阅“转到帮助生成”。
// 有关指定包的详细信息，请参阅“转到帮助包”。
// None
// 另见：去建造，去兽医。
// None
// None
// 运行指定的go工具
// None
// 用法：
// None
// go工具[-n]命令[args…]
// None
// 工具运行由参数标识的go Tool命令。
// 没有参数，它打印已知工具的列表。
// None
// -n标志使工具打印将要执行的命令
// 已执行但未执行。
// None
// 有关每个工具命令的详细信息，请参阅“go doc cmd/<command>”。
// None
// None
// 印刷版
// None
// 用法：
// None
// go版本[-m][v][file…]
// None
// 版本打印Go可执行文件的生成信息。
// None
// Go version报告用于生成每个命名组件的Go版本
// 可执行文件。
// None
// 如果命令行上没有命名文件，go版本将打印自己的文件
// 版本信息。
// None
// 如果一个目录被命名，go版本递归地遍历该目录，
// 查找可识别的Go二进制文件并报告其版本。
// 默认情况下，go版本不会报告找到的无法识别的文件
// 在目录扫描期间。-v标志导致它报告无法识别的文件。
// None
// -m标志使go版本打印每个可执行文件的嵌入
// 模块版本信息（如果可用）。在输出中，模块
// 信息由版本行后面的多行组成，每行
// 由前导制表符缩进的。
// None
// 另请参见：go doc runtime/debug.BuildInfo。
// None
// None
// 报告软件包中可能出现的错误
// None
// 用法：
// None
// go-vet[-n][-x][-vettool prog][build flags][vet flags][packages]
// None
// Vet对由导入路径命名的包运行Go-Vet命令。
// None
// 有关vet及其标志的更多信息，请参阅“go doc cmd/vet”。
// 有关指定包的详细信息，请参阅“转到帮助包”。
// 有关跳棋及其标志的列表，请参阅“go tool vet帮助”。
// 有关特定检查器（如“printf”）的详细信息，请参阅“go tool vet help printf”。
// None
// -n标志打印将要执行的命令。
// -x标志在命令执行时打印命令。
// None
// -vettool=prog标志选择一个不同的分析工具，该工具带有可选选项
// 或附加支票。
// 例如，可以使用以下命令构建和运行“阴影”分析器：
// None
// 转到install golang.org/x/tools/go/analysis/passs/shadow/cmd/shadow
// go vet-vettool=$（哪个阴影）
// None
// go-vet支持的构建标志是那些控制包解析的标志
// 和执行，例如-n、-x、-v、-tags和-toolexec。
// 有关这些标志的更多信息，请参阅“go help build”。
// None
// 另请参见：执行fmt，执行修复。
// None
// None
// 构建约束
// None
// 构建约束，也称为构建标记，是以
// None
// None
// None
// 它列出了文件应包含在包中的条件。
// 约束可能出现在任何类型的源文件中（不仅仅是Go），但
// 它们必须出现在文件顶部附近，前面有
// 仅限空行和其他行注释。这些规则意味着在围棋中
// 文件生成约束必须出现在package子句之前。
// None
// 要区分构建约束和包文档，
// 生成约束后面应该有一个空行。
// None
// 生成约束将作为包含选项的表达式进行计算
// 由| |，&&&，和组合而成！运算符和括号。运营商有
// 与围棋中的意思相同。
// None
// 例如，以下生成约束将文件约束为
// 在满足“linux”和“386”约束时生成，或者
// “达尔文”满意，“cgo”不满意：
// None
// None
// None
// 一个文件包含多个文件是错误的
// None
// 在特定构建过程中，满足以下条件：
// None
// -由runtime.GOOS拼写的目标操作系统，设置为
// GOOS环境变量。
// -目标体系结构（如runtime.GOARCH所述）设置为
// GOARCH环境变量。
// -正在使用的编译器，“gc”或“gccgo”
// -“cgo”，如果支持cgo命令（请参阅中的启用cgo_）
// “转到帮助环境”）。
// -每个Go主要版本的术语，通过当前版本：
// Go版本1.1之后的“go1.1”，go1.12之后的“go1.12”，依此类推。
// -由-tags标志提供的任何附加标记（请参阅“go help build”）。
// None
// beta版或次要版本没有单独的构建标签。
// None
// 如果文件名去掉扩展名和可能的测试后缀后，
// 匹配以下任何模式：
// *_粘液
// *_守门员
// *_古斯古阿奇
// （示例：source_windows_amd64.go）其中GOOS和GOARCH表示
// 任何已知的操作系统和架构值，然后
// 该文件被认为具有隐式生成约束
// 这些术语（除了文件中的任何显式约束）。
// None
// 使用GOOS=android与GOOS=linux一样匹配构建标记和文件
// 除了安卓标签和文件。
// None
// 使用GOOS=illumos与GOOS=solaris一样匹配构建标记和文件
// 除了illumos标签和文件之外。
// None
// 使用GOOS=ios可以像使用GOOS=darwin一样匹配构建标记和文件
// 除了ios标签和文件。
// None
// 要避免生成时考虑文件，请执行以下操作：
// None
// None
// None
// （任何其他不满意的词也可以，但“忽略”是常规用语。）
// None
// 要仅在使用cgo且仅在Linux和OS X上构建文件，请执行以下操作：
// None
// None
// None
// 这样的文件通常与实现
// 其他系统的默认功能，在本例中
// 进行约束：
// None
// None
// None
// 命名文件dns_windows.go将导致仅当
// 构建Windows软件包；同样，数学386.s也将包括在内
// 仅当为32位x86构建包时。
// None
// Go版本1.16和更早版本对构建约束使用了不同的语法，
// 带着一个“
// 遇到旧语法时的约束。
// None
// None
// 构建模式
// None
// “go build”和“go install”命令采用-buildmode参数，该参数
// 指示要生成哪种类型的对象文件。当前支持的值
// 是：
// None
// -buildmode=archive
// 将列出的非主程序包构建到.a文件中。名为
// 忽略了主要问题。
// None
// -buildmode=c-archive
// 构建列出的主包，以及它导入的所有包，
// 保存到C存档文件中。唯一可调用的符号将是
// 使用cgo导出的函数
// 只需列出一个主包。
// None
// -buildmode=c-shared
// 构建列出的主包，以及它导入的所有包，
// 进入C共享库。唯一可调用的符号将
// 这些函数是否使用cgo导出
// 只需要列出一个主包。
// None
// -buildmode=默认值
// 列出的主包内置在可执行文件中，并列出
// 非主程序包内置在.a文件中（默认值
// 行为）。
// None
// -buildmode=共享
// 将列出的所有非主包合并到一个共享包中
// 使用-linkshared创建时将使用的库
// 选项名为main的包被忽略。
// None
// -buildmode=exe
// 构建列出的主包及其导入的所有内容
// 可执行文件。未命名为main的包将被忽略。
// None
// -buildmode=pie
// 构建列出的主包及其导入的所有内容
// 定位独立可执行文件（PIE）。未命名的包
// 忽略了主要问题。
// None
// -buildmode=插件
// 构建列出的主包，以及它们所包含的所有包
// 导入到Go插件中。未命名为main的包将被忽略。
// None
// 在AIX上，当链接使用由
// -buildmode=c-archive，必须将-Wl，-bnobjreorder传递给c编译器。
// None
// None
// 在Go和C之间调用
// None
// Go和C/C++代码之间有两种不同的调用方式。
// None
// 第一个是cgo工具，它是Go发行版的一部分。对于
// 有关如何使用它的信息，请参阅cgo文档（go doc cmd/cgo）。
// None
// 第二个是SWIG程序，它是用于
// 语言之间的接口。有关SWIG的信息，请参阅
// http:
// 扩展将传递给SWIG。任何扩展名为.swigcxx的文件
// 将通过-c++选项传递给SWIG。
// None
// 当使用cgo或SWIG时，go构建将通过任何.c、.m、.s、.s
// 或.x文件到C编译器，以及.c++，.cp，.cxx文件到C++
// 编译器。可以设置CC或CXX环境变量以确定
// C或C++编译器分别使用。
// None
// None
// 构建和测试缓存
// None
// go命令缓存生成输出，以便在将来的生成中重用。
// 缓存数据的默认位置是名为go build的子目录
// 在当前操作系统的标准用户缓存目录中。
// 设置GOCACHE环境变量将覆盖此默认值，
// 运行“go env GOCACHE”将打印当前缓存目录。
// None
// go命令会定期删除尚未删除的缓存数据
// 最近用过。运行“go clean-cache”删除所有缓存数据。
// None
// 生成缓存正确地说明了对Go源文件所做的更改，
// 编译器、编译器选项等：显式清理缓存
// 在典型使用中不应是必需的。但是，构建缓存
// 不检测对使用cgo导入的C库的更改。
// 如果对系统上的C库进行了更改，则
// 将需要显式清理缓存，或者使用-a build标志
// （请参阅“go help build”）强制重新生成
// 取决于更新的C库。
// None
// go命令还缓存成功的包测试结果。
// 有关详细信息，请参阅“go help test”。运行“goclean-testcache”将删除
// 所有缓存的测试结果（但不是缓存的生成结果）。
// None
// GODEBUG环境变量可以启用调试的打印
// 有关缓存状态的信息：
// None
// GODEBUG=gocacheverify=1使go命令绕过
// 使用任何缓存项，而不是重建所有内容并检查
// 结果是否与现有缓存项匹配。
// None
// GODEBUG=gocachehash=1使go命令打印输入
// 对于它用来构造缓存查找键的所有内容哈希。
// 输出量很大，但对于调试缓存很有用。
// None
// GODEBUG=gocachetest=1使go命令打印其属性的详细信息
// 关于是否重用缓存的测试结果的决定。
// None
// None
// 环境变量
// None
// go命令及其调用的工具将查询环境变量
// 用于配置。如果环境变量未设置，则go命令
// 使用合理的默认设置。查看
// 变量<NAME>，运行'go env<NAME>'。要更改默认设置，
// 运行“go env-w<NAME>=<VALUE>”。使用“go env-w”更改默认值
// 记录在存储在中的Go环境配置文件中
// 按用户配置目录，由os.UserConfigDir报告。
// 可以通过设置更改配置文件的位置
// 环境变量GOENV和“go env GOENV”打印
// 有效位置，但“go env-w”无法更改默认位置。
// 有关详细信息，请参阅“go help env”。
// None
// 通用环境变量：
// None
// GO111模块
// 控制go命令是在模块感知模式下运行还是在GOPATH模式下运行。
// 可能是“关闭”、“打开”或“自动”。
// 请参阅https:
// GCCGO
// 为“go build-compiler=gccgo”运行的gccgo命令。
// 守门员
// 为其编译代码的体系结构或处理器。
// 例如amd64、386、arm、ppc64。
// 戈宾
// “go install”将在其中安装命令的目录。
// 戈cache
// go命令将存储缓存的目录
// 用于在未来构建中重用的信息。
// GOMODCACHE
// go命令将存储下载模块的目录。
// 哥德堡
// 启用各种调试工具。请参阅“go doc运行时”
// 详情请参阅。
// 戈恩
// Go环境配置文件的位置。
// 无法使用“go env-w”进行设置。
// 戈Flags
// 要应用的-flag=值设置的空格分隔列表
// 默认情况下，当给定标志为
// 当前命令。每个条目必须是独立的标志。
// 因为条目是空格分隔的，所以必须使用标志值
// 不包含空格。命令行上列出的标志
// 在该列表之后应用，因此将覆盖该列表。
// 甲状腺治疗
// 以逗号分隔的全局模式列表（采用Go的path.Match语法）
// 应始终以不安全的方式获取的模块路径前缀的数目
// 方式仅适用于直接获取的依赖项。
// GOINSECURE不禁用校验和数据库验证。私人的还是私人的
// GONOSUMDB可用于实现这一点。
// 粘液
// 为其编译代码的操作系统。
// 例如linux、darwin、windows和netbsd。
// 戈帕斯
// 有关更多详细信息，请参阅“转到帮助路径”。
// GOPROXY
// Go模块代理的URL。请参阅https:
// 和https:
// GOPRIVATE、GONOPROXY、GONOSUMDB
// 以逗号分隔的全局模式列表（采用Go的path.Match语法）
// 应始终直接获取的模块路径前缀的数目
// 或者不应与校验和数据库进行比较。
// 请参阅https:
// 戈鲁特
// 围棋树的根。
// GOSUMDB
// 要使用的校验和数据库的名称及其公钥（可选）和
// 网址。请参阅https:
// 戈特普迪尔
// go命令将写入的目录
// 临时源文件、包和二进制文件。
// 政府官员
// 列出可与匹配服务器一起使用的版本控制命令。
// 请参阅“帮助vcs”。
// None
// 用于cgo的环境变量：
// None
// 应收账
// 用于在以下情况下操作库存档的命令：
// 使用gccgo编译器构建。
// 默认值为“ar”。
// 科科斯群岛
// 用于编译C代码的命令。
// CGO_已启用
// 是否支持cgo命令。0或1。
// CGO_CFLAGS
// 编译时cgo将传递给编译器的标志
// C代码。
// CGO\u CFLAGS\u允许
// 一个正则表达式，指定要允许的其他标志
// 出现在#cgo CFLAGS源代码指令中。
// 不适用于CGO_CFLAGS环境变量。
// CGO不允许
// 指定必须禁用的标志的正则表达式
// 从出现在#cgo CFLAGS源代码指令中。
// 不适用于CGO_CFLAGS环境变量。
// CGO_CPPFLAGS，CGO_CPPFLAGS_允许，CGO_CPPFLAGS_不允许
// 像CGO\U CFLAGS一样，CGO\U CFLAGS\U允许，CGO\U CFLAGS\U不允许，
// 但是对于C预处理器。
// CGO\U CXXFLAGS，CGO\U CXXFLAGS\U允许，CGO\U CXXFLAGS\U不允许
// 像CGO\U CFLAGS一样，CGO\U CFLAGS\U允许，CGO\U CFLAGS\U不允许，
// 但是对于C++编译器来说。
// CGO\U FFLAGS，CGO\U FFLAGS\U允许，CGO\U FFLAGS\U不允许
// 像CGO\U CFLAGS一样，CGO\U CFLAGS\U允许，CGO\U CFLAGS\U不允许，
// 但是对于Fortran编译器。
// CGO_LDFLAGS，CGO_LDFLAGS_允许，CGO_LDFLAGS_不允许
// 像CGO\U CFLAGS一样，CGO\U CFLAGS\U允许，CGO\U CFLAGS\U不允许，
// 但是对于链接器。
// CXX
// 用来编译C++代码的命令。
// 常设费用
// 用于编译Fortran代码的命令。
// 包装配置
// pkg配置工具的路径。
// None
// 特定于体系结构的环境变量：
// None
// 守门员
// 对于GOARCH=arm，要编译的arm体系结构。
// 有效值为5、6、7。
// GO386
// 对于GOARCH=386，如何实现浮点指令。
// 有效值为sse2（默认值）、softfloat。
// 戈米普斯
// 对于GOARCH=mips{，le}，是否使用浮点指令。
// 有效值为硬浮点（默认）、软浮点。
// 戈米普斯64
// 对于GOARCH=mips64{，le}，是否使用浮点指令。
// 有效值为硬浮点（默认）、软浮点。
// GOPPC64
// 对于GOARCH=ppc64{，le}，目标ISA（指令集体系结构）。
// 有效值为power8（默认值）、power9。
// 戈瓦姆
// 对于GOARCH=wasm，使用逗号分隔的实验性WebAssembly特性列表。
// 有效值为satconv、signext。
// None
// 特殊用途环境变量：
// None
// GCCGOTOLDIR
// 如果设置了，在哪里可以找到gccgo工具，例如cgo。
// 默认值基于gccgo的配置方式。
// 实验
// 要启用或禁用的工具链实验的逗号分隔列表。
// 可用实验的列表可能随时间任意变化。
// 有关当前有效值，请参见src/internal/goexperiment/flags.go。
// 警告：此变量用于开发和测试
// Go工具链本身的一部分。不支持超出该用途的使用。
// 戈罗特欧决赛
// 已安装的Go树的根目录（如果已安装）
// 安装在非建造位置。
// 堆栈跟踪中的文件名从GOROOT重写为
// GOROOT_决赛。
// GO_EXTLINK_已启用
// 链接器是否应使用外部链接模式
// 将-linkmode=auto与使用cgo的代码一起使用时。
// 设置为0可禁用外部链接模式，设置为1可启用外部链接模式。
// GIT_允许_协议
// 由Git定义。允许的方案的冒号分隔列表
// 与git fetch/clone一起使用。如果已设置，则任何方案都不会显式
// “go-get”会将上述内容视为不安全。
// 因为变量是由Git定义的，所以不能使用默认值
// 可以使用“go env-w”进行设置。
// None
// “go env”中提供的但未从环境中读取的其他信息：
// None
// 戈克斯
// 可执行文件名后缀（在Windows上为“.exe”，在其他系统上为“.exe”）。
// GOGCCFLAGS
// 提供给CC命令的以空格分隔的参数列表。
// 戈霍斯塔克
// Go工具链二进制文件的体系结构（GOARCH）。
// 戈霍斯托斯
// Go工具链二进制文件的操作系统（GOOS）。
// 戈莫德
// 主模块go.mod的绝对路径。
// 如果启用模块感知模式，但没有go.mod，则GOMOD将被禁用
// os.DevNull（在类Unix系统上为“/dev/null”，在Windows上为“NUL”）。
// 如果禁用模块感知模式，GOMOD将为空字符串。
// 戈图尔迪尔
// 安装go工具（编译、封面、文档等）的目录。
// 政府
// runtime.version报告的已安装Go树的版本。
// None
// None
// 文件类型
// None
// go命令检查一组受限文件的内容
// 在每个目录中。它标识要基于哪些文件进行检查
// 文件名的扩展名。这些扩展是：
// None
// 去
// 转到源文件。
// .c、.h
// C源文件。
// 如果包使用cgo或SWIG，则将使用
// OS本机编译器（通常为gcc）；否则他们会的
// 触发一个错误。
// .cc、.cpp、.cxx、.hh、.hpp、.hxx
// C++源文件。仅适用于cgo或SWIG，并且始终
// 使用操作系统本机编译器编译。
// M
// Objective-C源文件。仅适用于cgo，并且始终
// 使用操作系统本机编译器编译。
// .s、.s、.sx
// 汇编程序源文件。
// 如果包使用cgo或SWIG，则这些将与
// 操作系统本机汇编程序（通常为gcc（sic））；否则他们
// 将使用Go汇编程序进行组装。
// .swig、.swigcxx
// SWIG定义文件。
// 西索先生
// 系统对象文件。
// None
// 除.syso之外的每种类型的文件都可能包含内部版本
// 约束，但go命令停止扫描生成约束
// 在文件中不是空行的第一项或
// 行注释。有关详细信息，请参阅go/build软件包文档
// 更多细节。
// None
// None
// go.mod文件
// None
// 模块版本由源文件树定义，带有go.mod
// 文件在其根目录中。运行go命令时，它将在当前
// 目录，然后是连续的父目录以查找go.mod
// 标记主（电流）模块的根。
// None
// go.mod文件格式在中有详细说明
// https:
// None
// 要创建新的go.mod文件，请使用“go mod init”。详情请参阅
// “go help mod init”或https：
// None
// 要添加缺失的模块需求或删除不必要的需求，
// 使用“go mod tidy”。有关详细信息，请参阅“go help mod tidy”或
// https:
// None
// 要添加、升级、降级或删除特定模块需求，请使用
// “去拿”。有关详细信息，请参阅“转到帮助模块获取”或
// https:
// None
// 要进行其他更改或将go.mod解析为JSON以供其他工具使用，
// 使用“go mod edit”。请参阅“go help mod edit”或
// https:
// None
// None
// GOPATH环境变量
// None
// Go路径用于解析导入语句。
// 它由go/build包实现并记录在其中。
// None
// GOPATH环境变量列出查找Go代码的位置。
// 在Unix上，该值是以冒号分隔的字符串。
// 在Windows上，该值是以分号分隔的字符串。
// 在计划9中，该值是一个列表。
// None
// 如果环境变量未设置，则默认为GOPATH
// 到用户主目录中名为“go”的子目录
// （$HOME/go在Unix上，%USERPROFILE%\go在Windows上），
// 除非该目录包含Go发行版。
// 运行“go env GOPATH”查看当前GOPATH。
// None
// 请参阅https:
// None
// GOPATH中列出的每个目录必须具有指定的结构：
// None
// src目录保存源代码。src下面的路径
// 确定导入路径或可执行文件名。
// None
// pkg目录保存已安装的包对象。
// 与Go树中一样，每个目标操作系统和
// 架构对有自己的pkg子目录
// （包装/古斯古阿奇）。
// None
// 如果DIR是GOPATH中列出的目录，则包含
// DIR/src/foo/bar中的源可以作为“foo/bar”和
// 已将其编译后的表单安装到“DIR/pkg/GOOS_GOARCH/foo/bar.a”。
// None
// bin目录保存已编译的命令。
// 每个命令都以其源目录命名，但仅限于
// 最后一个元素，而不是整个路径。就是
// 源代码为DIR/src/foo/qux的命令安装到
// DIR/bin/qux，而不是DIR/bin/foo/qux。去掉“foo/”前缀
// 这样，您就可以将DIR/bin添加到路径中，以获取
// 已安装的命令。如果GOBIN环境变量为
// 设置时，命令将安装到它指定的目录中
// DIR/bin的名称。戈宾必须是一条绝对路径。
// None
// 下面是一个目录布局示例：
// None
// GOPATH=/home/user/go
// None
// /主页/用户/转到/
// src/
// 福/
// 条形码/（包装栏中的go代码）
// x、 去
// quux/（主程序包中的go代码）
// y、 去
// 垃圾箱/
// quux（已安装命令）
// 包装/
// linux_amd64/
// 福/
// bar.a（已安装的包对象）
// None
// Go搜索GOPATH中列出的每个目录以查找源代码，
// 但新软件包总是下载到第一个目录中
// 在名单上。
// None
// 请参阅https:
// None
// GOPATH和模块
// None
// 使用模块时，GOPATH不再用于解析导入。
// 但是，它仍然用于存储下载的源代码（在GOPATH/pkg/mod中）
// 和编译命令（在GOPATH/bin中）。
// None
// 内部目录
// None
// 名为“internal”的目录中或目录下的代码仅可导入
// 通过“internal”父目录树中的代码。
// 下面是上面目录布局的扩展版本：
// None
// /主页/用户/转到/
// src/
// 撞车/
// bang/（包bang中的go代码）
// b、 去
// foo/（包foo中的go代码）
// f、 去
// 条形码/（包装栏中的go代码）
// x、 去
// 内部的/
// baz/（包baz中的go代码）
// z、 去
// quux/（主程序包中的go代码）
// y、 去
// None
// None
// z.go中的代码作为“foo/internal/baz”导入，但是
// import语句只能出现在子树的源文件中
// 扎根于福。源文件foo/f.go、foo/bar/x.go和
// foo/qux/y.go可以全部导入“foo/internal/baz”，但是源文件
// 撞车/砰的一声/b.走不动。
// None
// 请参阅https:
// None
// 供应商目录
// None
// Go 1.6支持使用外部依赖项的本地副本
// 为了满足这些依赖项的导入，通常称为vendoring。
// None
// 名为“供应商”的目录下的代码仅可导入
// 通过“供应商”父目录树中的代码，
// 并且仅使用省略前缀的导入路径，最多和
// 包括供应商元素。
// None
// 这是上一节的例子，
// 但将“内部”目录重命名为“供应商”
// 并添加了一个新的foo/vendor/crash/bang目录：
// None
// /主页/用户/转到/
// src/
// 撞车/
// bang/（包bang中的go代码）
// b、 去
// foo/（包foo中的go代码）
// f、 去
// 条形码/（包装栏中的go代码）
// x、 去
// 卖主/
// 撞车/
// bang/（包bang中的go代码）
// b、 去
// baz/（包baz中的go代码）
// z、 去
// quux/（主程序包中的go代码）
// y、 去
// None
// 与内部的可见性规则相同，但代码
// 在z.go中，导入为“baz”，而不是“foo/vendor/baz”。
// None
// 源代码树阴影中较深的供应商目录中的代码
// 代码在更高的目录中。在以foo为根的子树中，导入
// “崩溃/爆炸”的解析为“foo/vendor/crash/bang”，而不是
// 顶级“碰撞/爆炸”。
// None
// 供应商目录中的代码不受导入路径的约束
// 正在检查（请参阅“转到帮助导入路径”）。
// None
// 当“go get”签出或更新git存储库时，它现在也
// 更新子模块。
// None
// 供应商目录不会影响新存储库的放置
// 第一次被“go get”签出：这些总是
// 放置在主GOPATH中，而不是供应商子树中。
// None
// 请参阅https:
// None
// None
// 传统GOPATH go get
// None
// “go get”命令会根据
// go命令正在模块感知模式或传统GOPATH模式下运行。
// 此帮助文本即使在模块感知模式下也可作为“go help gopath get”访问，
// 描述在传统GOPATH模式下运行的“go-get”。
// None
// 用法：获取[-d][f][t][u][v][fix][build flags][packages]
// None
// Get下载由导入路径命名的包及其名称
// 依赖关系。然后安装命名的软件包，如“go install”。
// None
// -d标志指示get在下载包后停止；就是，
// 它指示get不要安装软件包。
// None
// -f标志仅在设置了-u时有效，它强制get-u不验证这一点
// 每个包都已从源代码管理存储库中签出
// 由其导入路径暗示。如果源是本地fork，这可能很有用
// 原版的。
// None
// -fix标志指示get在下载的包上运行修复工具
// 在解析依赖项或生成代码之前。
// None
// t标志指示get也下载构建所需的包
// 指定包的测试。
// None
// u标志指示get使用网络更新命名包
// 以及它们的依赖关系。默认情况下，get使用网络进行签出
// 缺少包，但不使用它查找现有包的更新。
// None
// -v标志启用详细进度和调试输出。
// None
// Get还接受生成标志来控制安装。请参阅“go help build”。
// None
// 签出新包时，get将创建目标目录
// GOPATH/src/<import path>。如果GOPATH包含多个条目，
// 得到第一个。有关更多详细信息，请参阅“转到帮助路径”。
// None
// 签出或更新包时，get会查找分支或标记
// 与本地安装的Go版本相匹配。最重要的
// 规则是，如果本地安装运行的是版本“go1”，则获取
// 搜索名为“go1”的分支或标记。如果不存在这样的版本
// 它检索包的默认分支。
// None
// 当go get签出或更新Git存储库时，
// 它还更新存储库引用的任何git子模块。
// None
// Get从不签出或更新存储在供应商目录中的代码。
// None
// 有关指定包的详细信息，请参阅“转到帮助包”。
// None
// 有关“go get”如何查找源代码的更多信息，请参见
// 下载，请参阅“转到帮助导入路径”。
// None
// 本文描述了使用GOPATH时get的行为
// 管理源代码和依赖项。
// 如果go命令在模块感知模式下运行，
// get的标志和效果的细节会发生变化，“go help get”也是如此。
// 请参阅“转到帮助模块”和“转到帮助模块获取”。
// None
// 另请参见：开始构建、开始安装、开始清理。
// None
// None
// 模块代理协议
// None
// Go模块代理是可以响应GET请求的任何web服务器
// 指定表单的URL。请求没有查询参数，因此
// 从固定文件系统提供服务的站点（包括文件：
// 可以是模块代理。
// None
// 有关GOPROXY协议的详细信息，请参阅
// https:
// None
// None
// 导入路径语法
// None
// 导入路径（请参阅“go help packages”）表示存储在本地数据库中的包
// 文件系统。通常，导入路径表示标准包（例如
// 作为“unicode/utf8”）或在其中一个工作空间中找到的包（有关更多信息
// 详细信息请参见：“go help gopath”）。
// None
// 相对导入路径
// None
// 以./或../开头的导入路径称为相对路径。
// 工具链以两种方式支持相对导入路径作为快捷方式。
// None
// 首先，相对路径可以用作命令行上的简写。
// 如果您在包含作为导入的代码的目录中工作
// “unicode”和要运行“unicode/utf8”的测试，可以键入
// “go test./utf8”而不需要指定完整路径。
// 类似地，在相反的情况下，“go test…”将从中测试“unicode”
// “unicode/utf8”目录。还允许使用相对模式，如
// “go test./…”以测试所有子目录。有关详细信息，请参阅“go帮助包”
// 关于模式语法。
// None
// 第二，如果你不是在工作空间编译围棋程序，
// 您可以在该程序的导入语句中使用相对路径
// 参考不在工作空间内的附近代码。
// 这使得使用小型多包程序进行实验变得很容易
// 在通常的工作空间之外，但这样的程序不能
// 安装“go install”（没有安装它们的工作空间），
// 因此，它们每次建造时都是从头开始重建的。
// 为避免歧义，Go程序不能使用相对导入路径
// 在工作空间内。
// None
// 远程导入路径
// None
// 某些导入路径也可以
// 描述如何使用获取包的源代码
// 修订控制系统。
// None
// 一些常见的代码托管站点具有特殊语法：
// None
// 比特桶（Git，Mercurial）
// None
// 导入“bitbucket.org/user/project”
// 导入“bitbucket.org/user/project/sub/directory”
// None
// GitHub（Git）
// None
// 导入“github.com/user/project”
// 导入“github.com/user/project/sub/directory”
// None
// 发射台（集市）
// None
// 导入“launchpad.net/project”
// 导入“launchpad.net/project/series”
// 导入“launchpad.net/project/series/sub/directory”
// None
// 导入“launchpad.net/~user/project/branch”
// 导入“launchpad.net/~user/project/branch/sub/directory”
// None
// IBM DevOps服务（Git）
// None
// 导入“hub.jazz.net/git/user/project”
// 导入“hub.jazz.net/git/user/project/sub/directory”
// None
// 对于托管在其他服务器上的代码，导入路径可以是限定的
// 使用版本控制类型，或者go工具可以动态获取
// https/http上的导入路径，并发现代码所在的位置
// 从HTML中的<meta>标记。
// None
// 要声明代码位置，请输入表单的导入路径
// None
// repository.vcs/path
// None
// 指定给定的存储库，带或不带.vcs后缀，
// 使用命名的版本控制系统，然后在
// 那个仓库。支持的版本控制系统包括：
// None
// 巴扎
// 化石，化石
// 吉特，吉特
// 汞汞
// 颠覆
// None
// 例如
// None
// 导入“example.org/user/foo.hg”
// None
// 表示位于的Mercurial存储库的根目录
// example.org/user/foo或foo.hg，以及
// None
// 导入“example.org/repo.git/foo/bar”
// None
// 表示位于的Git存储库的foo/bar目录
// example.org/repo或repo.git。
// None
// 当版本控制系统支持多个协议时，
// 每次下载时都会依次尝试。例如，Git
// 下载https:
// None
// 默认情况下，下载仅限于已知的安全协议
// （例如https、ssh）。要覆盖Git下载的此设置，请
// 可以设置GIT_ALLOW_协议环境变量（有关更多详细信息，请参阅：
// “转到帮助环境”）。
// None
// 如果导入路径不是已知的代码宿主站点，并且缺少
// 版本控制限定符，go工具尝试获取导入
// 并在文档的HTML中查找<meta>标记
// <head>。
// None
// meta标记的形式如下：
// None
// <meta name=“go import”content=“导入前缀vcs回购根”>
// None
// 导入前缀是与存储库对应的导入路径
// 根它必须是一个前缀，或者与正在运行的包完全匹配
// 用“go get”获取。如果不完全匹配，则另一个http
// 在前缀处发出请求以验证<meta>标记是否匹配。
// None
// meta标记应尽可能早地出现在文件中。
// 特别是，它应该出现在任何原始JavaScript或CSS之前，
// 避免混淆go命令的受限解析器。
// None
// vcs是“bzr”、“化石”、“git”、“hg”、“svn”中的一种。
// None
// repo根目录是版本控制系统的根目录
// 包含方案但不包含.vcs限定符。
// None
// 例如
// None
// 导入“example.org/pkg/foo”
// None
// 将导致以下请求：
// None
// https:
// http:
// None
// 如果该页面包含meta标记
// None
// <meta name=“go import”content=“example.org git https:
// None
// go工具将验证https：
// 相同的元标记，然后是git clone https：
// GOPATH/src/example.org。
// None
// 使用GOPATH时，下载的包将写入第一个目录
// 在GOPATH环境变量中列出。
// （请参阅“go help gopath get”和“go help gopath”。）
// None
// 使用模块时，下载的软件包存储在模块缓存中。
// 请参阅https:
// None
// 使用模块时，go import meta标记的另一个变体是
// 认可并优于列出的版本控制系统。
// 该变体使用“mod”作为内容值中的vcs，如中所示：
// None
// <meta name=“go import”content=“example.org mod https:
// None
// 此标记表示获取路径以example.org开头的模块
// 从URL https上可用的模块代理：
// 请参阅https:
// 代理协议。
// None
// 导入路径检查
// None
// 当上述自定义导入路径功能重定向到
// 已知代码托管站点，每个生成的包都有两个可能的
// 使用自定义域或已知托管站点导入路径。
// None
// 如果一个包语句立即被调用，则称它具有“导入注释”
// （在下一个换行之前）后面是以下两种形式之一的注释：
// None
// 包数学
// 包数学/*导入“路径”*/
// None
// go命令将拒绝安装带有导入注释的包
// 除非该导入路径引用它。这样，就可以导入注释
// 让包作者确保使用了自定义导入路径，而不是
// 指向基础代码宿主站点的直接路径。
// None
// 在供应商树中找到的代码禁用导入路径检查。
// 这使得将代码复制到供应商树中的备用位置成为可能
// 无需更新导入注释。
// None
// 使用模块时，导入路径检查也被禁用。
// 导入路径注释被go.mod文件的module语句废弃。
// None
// 请参阅https:
// None
// None
// 模块、模块版本等
// None
// 模块是管理依赖关系的方式。
// None
// 模块是已发布、已版本化和已发布的包的集合
// 一起分发。模块可以直接从版本控制下载
// 存储库或模块代理服务器。
// None
// 有关模块的一系列教程，请参见
// https:
// None
// 有关模块的详细参考，请参阅https:
// None
// 默认情况下，go命令可以从https下载模块：
// 它可以在以下位置使用校验和数据库对模块进行身份验证：
// https:
// 有关这些服务的隐私政策，请访问
// https:
// 分别地
// None
// go命令的下载行为可以使用GOPROXY、GOSUMDB、，
// GOPRIVATE和其他环境变量。请参阅“帮助环境”
// 和https:
// None
// None
// 使用go.sum进行模块身份验证
// None
// 当go命令将模块zip文件或go.mod文件下载到
// 模块缓存时，它计算加密哈希并将其与已知哈希进行比较
// 值，以验证文件自首次下载后未更改。已知的
// 散列存储在模块根目录中名为go.sum的文件中。散列
// 也可以从校验和数据库下载，具体取决于
// GOSUMDB、GOPRIVATE和GONOSUMMDB。
// None
// 有关详细信息，请参阅https:
// None
// None
// 包列表和模式
// None
// 许多命令适用于一组软件包：
// None
// 行动[套餐]
// None
// 通常，[packages]是导入路径的列表。
// None
// 根路径或以开头的导入路径
// A.或元素被解释为文件系统路径和
// 表示该目录中的包。
// None
// 否则，导入路径P表示在中找到的包
// GOPATH中列出的某些目录的目录DIR/src/P
// 环境变量（有关更多详细信息，请参阅“go help gopath”）。
// None
// 如果未给出导入路径，则该操作将应用于
// 当前目录中的包。
// None
// 对于不应使用的路径，有四个保留名称
// 对于要使用go工具构建的包：
// None
// -“main”表示独立可执行文件中的顶级包。
// None
// -“all”扩展到所有GOPATH中找到的所有包
// 树。例如，“go list all”列出本地服务器上的所有包
// 系统使用模块时，“全部”扩展到中的所有包
// 主模块及其依赖项，包括依赖项
// 任何这些测试都需要。
// None
// -“std”与所有标准类似，但仅扩展到标准中的包
// 去图书馆。
// None
// -“cmd”扩展到Go存储库的命令及其
// 内部图书馆。
// None
// 以“cmd/”开头的导入路径仅与中的源代码匹配
// Go存储库。
// None
// 如果导入路径包含一个或多个“…”通配符，则它是一种模式，
// 每一个都可以匹配任何字符串，包括空字符串和
// 包含斜杠的字符串。这种模式扩展到所有包
// 在GOPATH树中找到的名称与
// 模式。
// None
// 为了使普通模式更方便，有两种特殊情况。
// 首先，/。。。在模式的末尾可以匹配一个空字符串，
// 因此，网络/。。。匹配net及其子目录中的包，如net/http。
// 第二，任何包含通配符的斜杠分隔模式元素
// 参与供应商路径中“供应商”元素的匹配
// 包装，以便。/。。。与的子目录中的包不匹配
// /vendor或/mycode/vendor，但是/vendor/。。。和./mycode/vendor/。。。做
// 但是，请注意，名为vendor的目录本身包含代码
// 不是供应商程序包：cmd/vendor将是名为vendor的命令，
// 还有模式cmd/。。。与之匹配。
// 有关供应商的更多信息，请参见golang.org/s/go15vendor。
// None
// 导入路径还可以命名要从中下载的包
// 远程存储库。有关详细信息，请运行“go help importpath”。
// None
// 程序中的每个包都必须具有唯一的导入路径。
// 按照惯例，这是通过以
// 属于您的唯一前缀。例如，所使用的路径
// 在谷歌内部，一切都以“谷歌”和路径开头
// 指示远程存储库以代码的路径开始，
// 例如“github.com/user/repo”。
// None
// 程序中的包不需要具有唯一的包名称，
// 但有两个具有特殊含义的保留包名称。
// 名称main表示命令，而不是库。
// 命令内置于二进制文件中，无法导入。
// documentation的名称表示文档的名称
// 目录中的非Go程序。包文档中的文件
// 被go命令忽略。
// None
// 作为特例，如果包列表是来自
// 单个目录，该命令应用于单个目录
// 包完全由这些文件组成，忽略任何构建约束
// 并忽略目录中的任何其他文件。
// None
// 以“.”或“\”开头的目录和文件名将被忽略
// 通过go工具，以及名为“testdata”的目录。
// None
// None
// 下载非公开代码的配置
// None
// go命令默认为从公共go模块下载模块
// 镜像地址：proxy.golang.org。它还默认验证下载的模块，
// 无论来源如何，都可以访问sum.golang.org上的公共Go校验和数据库。
// 这些默认值适用于公开可用的源代码。
// None
// GOPRIVATE环境变量控制go命令的模块
// 认为是私有的（不公开），因此不应使用
// 代理或校验和数据库。变量是以逗号分隔的
// 模块路径前缀的全局模式（语法为Go的path.Match）。
// 例如
// None
// GOPRIVATE=*.corp.example.com，rsc.io/private
// None
// 使go命令将任何具有路径前缀的模块视为专用模块
// 匹配任一模式，包括git.corp.example.com/xyzy、rsc.io/private、，
// 和rsc.io/private/qux。
// None
// 对于模块下载和验证的细粒度控制，GONOPROXY
// 和GONOSUMDB环境变量接受相同类型的全局列表
// 并覆盖GOPRIVATE，以决定是否使用代理
// 和校验和数据库。
// None
// 例如，如果一家公司运行一个为私有模块服务的模块代理，
// 用户将使用以下方式配置go：
// None
// GOPRIVATE=*.corp.example.com
// GOPROXY=proxy.example.com
// 促性腺激素=无
// None
// GOPRIVATE变量还用于定义“public”和“private”
// GOVCS变量的模式；请参阅“帮助vcs”。对于这种用法，
// GOPRIVATE即使在GOPATH模式下也适用。在这种情况下，它匹配导入路径
// 而不是模块路径。
// None
// “go env-w”命令（请参阅“go help env”）可用于设置这些变量
// 用于将来的go命令调用。
// None
// 有关更多详细信息，请参阅https:
// None
// None
// 测试标志
// None
// “go test”命令接受应用于“go test”本身的两个标志
// 以及应用于生成的测试二进制文件的标志。
// None
// 几个标志控制分析和写入执行分析
// 适用于“围棋工具”；运行“go tool pprof-h”了解更多信息
// 信息--alloc_空间、--alloc_对象和--show_字节
// 控制信息显示方式的选项。
// None
// “go test”命令可以识别以下标志，并且
// 控制任何测试的执行：
// None
// -bench regexp
// 只运行与正则表达式匹配的基准测试。
// 默认情况下，不运行任何基准测试。
// 要运行所有基准测试，请使用“-bench.”或“-bench=”。
// 正则表达式由无支撑斜杠（/）拆分
// 将字符转换为正则表达式序列，并且每个
// 基准的部分标识符必须与相应的
// 序列中的元素（如果有）。可能是火柴的父母
// 以b.N=1运行，以确定子基准。例如
// 给定-bench=X/Y，运行与X匹配的顶级基准
// b.N=1，以查找与Y匹配的任何子基准，其为
// 然后全速跑。
// None
// -板凳时间t
// 对每个基准运行足够多的迭代，以获取指定的t
// 作为一个time.Duration（例如，-benchtime 1h30s）。
// 默认值为1秒（1秒）。
// 特殊语法Nx表示运行基准测试N次
// （例如，-benchtime 100x）。
// None
// None
// 运行每个测试和基准n次（默认值为1）。
// 如果设置了-cpu，则为每个GOMAXPROCS值运行n次。
// 示例总是运行一次。
// None
// -掩护
// 启用覆盖率分析。
// 请注意，因为覆盖率是通过注释源来工作的
// 编译前的代码，编译和测试失败
// 启用覆盖率可能会报告不对应的行号
// 到原始来源。
// None
// -覆盖模式集、计数、原子
// 为包[s]设置覆盖率分析模式
// 正在测试中。默认值为“设置”，除非启用了-race，
// 在这种情况下，它是“原子的”。
// 价值观：
// set:bool:此语句是否运行？
// count:int：这个语句运行多少次？
// 原子：int:count，但在多线程测试中正确；
// 要贵得多。
// 套-封面。
// None
// -封面包装图案1、图案2、图案3
// 在每个测试中对匹配模式的包应用覆盖率分析。
// 默认情况下，每个测试只分析正在测试的包。
// 有关包模式的描述，请参阅“go help packages”。
// 套-封面。
// None
// -中央处理器1,2,4
// 指定要为其执行测试或
// 应当执行基准。默认值为当前值
// GOMAXPROCS的。
// None
// -失败
// 第一次测试失败后，不要启动新测试。
// None
// -列表regexp
// 列出与正则表达式匹配的测试、基准测试或示例。
// 不会运行任何测试、基准测试或示例。这只会
// 列出顶级测试。不会显示任何子测试或子基准测试。
// None
// -平行的
// 允许并行执行调用t.parallel的测试函数。
// 此标志的值是要运行的最大测试数
// 同时默认情况下，它设置为GOMAXPROCS的值。
// 请注意，-parallel仅适用于单个测试二进制文件。
// “go test”命令可以为不同的包运行测试
// 同时，根据-p标志的设置
// （请参阅“go help build”）。
// None
// -运行regexp
// 仅运行与正则表达式匹配的测试和示例。
// 对于测试，正则表达式由无支撑斜杠（/）拆分
// 将字符转换为正则表达式序列，并且每个部分
// 测试标识符的类型必须与中的相应元素匹配
// 序列，如果有的话。请注意，匹配项的可能父项是
// 也运行，以便-run=X/Y匹配并运行并报告结果
// 在所有匹配X的测试中，即使没有匹配Y的子测试，
// 因为它必须运行它们来寻找那些子测试。
// None
// -短
// 告诉长时间运行的测试缩短其运行时间。
// 默认情况下，它处于关闭状态，但在all.bash期间设置，以便安装
// Go树可以运行健全性检查，但不能花时间运行
// 详尽的测试。
// None
// -洗牌
// 随机化测试和基准测试的执行顺序。
// 默认情况下，它处于关闭状态。如果-shuffle设置为on，则它将进行种子设定
// 使用系统时钟的随机发生器。If-shuffle设置为
// 整数N，则N将用作种子值。在这两种情况下，
// 将报告种子的再现性。
// None
// -超时d
// 如果测试二进制文件的运行时间超过持续时间d，则会出现死机。
// 如果d为0，则禁用超时。
// 默认值为10分钟（10米）。
// None
// -五
// 详细输出：记录所有运行的测试。也打印所有
// 来自Log和Logf的文本调用，即使测试成功。
// None
// -兽医名单
// 配置“go test”期间对“go vet”的调用
// 使用逗号分隔的兽医检查列表。
// 如果列表为空，“go test”将运行“go vet”，其中包含一个精心策划的
// 人们认为支票总是值得处理的。
// 若列表为“off”，则“go test”根本不运行“go vet”。
// None
// “go test”也可以识别以下标志，并可用于
// 在执行过程中分析测试：
// None
// -长凳
// 打印基准测试的内存分配统计信息。
// None
// -blockprofile block.out
// 将goroutine阻塞配置文件写入指定文件
// 当所有测试完成时。
// 像-c一样写入测试二进制文件。
// None
// -块速率
// 通过以下方式控制goroutine阻塞配置文件中提供的详细信息：
// 正在使用n调用runtime.SetBlockProfileRate。
// 请参阅“go doc runtime.SetBlockProfileRate”。
// 分析器的目标是平均每个月对一个阻塞事件进行采样
// n纳秒，程序被阻止。默认情况下，
// 如果在没有此标志的情况下设置-test.blockprofile，则所有阻塞事件
// 记录，相当于-test.blockprofilerate=1。
// None
// -coverprofile cover.out
// 通过所有测试后，向文件写入覆盖率配置文件。
// 套-封面。
// None
// -cpp文件cpu.out
// 退出前，将CPU配置文件写入指定文件。
// 像-c一样写入测试二进制文件。
// None
// -memprofile mem.out
// 通过所有测试后，将分配配置文件写入文件。
// 像-c一样写入测试二进制文件。
// None
// -膜速率
// 通过以下方式实现更精确（且更昂贵）的内存分配配置文件
// 正在设置runtime.MemProfileRate。请参阅“go doc runtime.MemProfileRate”。
// 要分析所有内存分配，请使用-test.memprofilerate=1。
// None
// -mutexprofile mutex.out
// 将互斥争用配置文件写入指定文件
// 当所有测试完成时。
// 像-c一样写入测试二进制文件。
// None
// -互斥滤波器
// 样本1/n包含一个
// 竞争互斥。
// None
// -outputdir目录
// 将分析的输出文件放在指定目录中，
// 默认情况下，运行“go test”的目录。
// None
// -追踪
// 退出前，将执行跟踪写入指定文件。
// None
// 这些标志中的每一个都可以通过可选的“test.”前缀识别，
// 如测试v。调用生成的测试二进制文件时（
// “go test-c”）直接输入，但是前缀是必需的。
// None
// “go test”命令重写或删除识别的标志，
// 视情况而定，在可选包列表之前和之后，
// 在调用测试二进制文件之前。
// None
// 例如，命令
// None
// go test-v-myflag testdata-cpuprofile=prof.out-x
// None
// 将编译测试二进制文件，然后作为
// None
// pkg.test-test.v-myflag testdata-test.cpuprofile=prof.out
// None
// （由于-x标志仅适用于go命令的
// 执行，而不是测试本身。）
// None
// 生成概要文件（覆盖范围除外）的测试标志也
// 在pkg.test中保留测试二进制文件，以便在分析概要文件时使用。
// None
// 当“go test”运行测试二进制文件时，它会在
// 对应包的源代码目录。根据测试结果，
// 调用生成的测试时，可能需要执行相同的操作
// 直接二进制。
// None
// 命令行程序包列表（如果存在）必须出现在任何
// go test命令未知的标志。继续上面的例子，
// 包列表必须出现在-myflag之前，但可能会出现
// 在-v的两边。
// None
// 在包列表模式下运行“go test”时，“go test”缓存成功
// 将测试结果打包，以避免不必要的重复运行测试。到
// 禁用测试缓存，使用除
// 可缓存标志。显式禁用测试缓存的惯用方法
// 是使用-count=1。
// None
// 防止测试二进制文件的参数被解释为
// 已知标志或包名，请使用-args（请参阅“go help test”），其中
// 将命令行的其余部分传递给测试二进制文件
// 毫无疑问的和不变的。
// None
// 例如，命令
// None
// 进行测试-v-args-x-v
// None
// 将编译测试二进制文件，然后作为
// None
// 包装测试-测试v-x-v
// None
// 同样地，
// None
// 进行测试-args数学
// None
// 将编译测试二进制文件，然后作为
// None
// 测试数学
// None
// 在第一个示例中，将-x和第二个-v传递给
// 测试二进制文件不变，对go命令本身没有影响。
// 在第二个示例中，参数math被传递给测试
// 二进制，而不是被解释为包列表。
// None
// None
// 测试功能
// None
// “go test”命令期望找到测试、基准测试和示例函数
// 在与被测包对应的“*_test.go”文件中。
// None
// 测试函数名为TestXxx（其中Xxx不以
// 小写字母）并应有签名，
// None
// func TestXxx（t*testing.t）{…}
// None
// 基准函数是一个名为BenchmarkXxx的函数，应该有签名，
// None
// func BenchmarkXxx（b*testing.b）{…}
// None
// 示例函数类似于测试函数，但不是使用
// *testing.T要报告成功或失败，请将输出打印到os.Stdout。
// 如果函数中的最后一条注释以“Output:”开头，则输出
// 与注释进行精确比较（参见下面的示例）。如果最后
// 注释以“无序输出”开头，然后将输出与
// 注释，但忽略行的顺序。没有这样的例子
// 注释已编译但未执行。后面没有文本的示例
// “Output:”被编译、执行，预期不会产生任何输出。
// None
// Godoc显示ExampleXxx的主体以演示其使用
// 函数、常数或变量Xxx的。使用M的方法的一个示例
// 接收器类型T或*T被命名为ExampleT\u M。可能有多个示例
// 对于给定的函数、常数或变量，用尾随的_xxx来区分，
// 其中xxx是一个后缀，不以大写字母开头。
// None
// 下面是一个示例的示例：
// None
// func ExamplePrintln（）{
// Println（“此示例的输出”）
// None
// None
// }
// None
// 下面是另一个忽略输出顺序的示例：
// None
// func ExamplePerm（）{
// 对于u，值：=范围Perm（4）{
// 格式打印项次（值）
// }
// None
// None
// None
// None
// None
// None
// }
// None
// 当整个测试文件包含一个
// 示例函数，至少一个其他函数、类型、变量或常量
// 声明，并且没有测试或基准函数。
// None
// 有关更多信息，请参阅测试包的文档。
// None
// None
// 用GOVCS控制版本控制
// None
// “go-get”命令可以运行git之类的版本控制命令
// 下载导入的代码。这一功能对于分散的应用程序至关重要
// Go package生态系统，其中代码可以从任何服务器导入，
// 但是，如果恶意服务器发现
// 导致调用的版本控制命令运行意外代码的方法。
// None
// 为了平衡功能和安全问题，“go-get”命令
// 默认情况下，将仅使用git和hg从公共服务器下载代码。
// 但它将使用任何已知的版本控制系统（bzr、fossil、git、hg、svn）
// 从专用服务器（定义为托管软件包的服务器）下载代码
// 匹配GOPRIVATE变量（请参阅“go help private”）。背后的理由
// 只允许Git和Mercurial是这两个系统拥有最多的功能
// 注意作为不受信任服务器的客户端运行的问题。相反
// Bazaar、Fossil和Subversion主要用于trusted，
// 经过身份验证的环境和攻击面没有受到严格的检查。
// None
// 版本控制命令限制仅在使用direct版本时适用
// 控制对下载代码的访问。从代理下载模块时，
// “go-get”使用始终允许的代理协议。
// 默认情况下，“go get”命令使用go模块镜像（proxy.golang.org）
// 对于公共软件包，只返回到私有软件包的版本控制
// 包或镜像拒绝提供公共包（通常用于
// （法律原因）。因此，客户端仍然可以访问从
// 默认情况下，Bazaar、Fossil或Subversion存储库，因为这些下载
// 使用Go模块镜像，它承担运行
// 使用自定义沙盒的版本控制命令。
// None
// GOVCS变量可用于更改允许的版本控制系统
// 对于特定包（由模块或导入路径标识）。
// GOVCS变量在两种模块感知模式下构建包时均适用
// 和GOPATH模式。使用模块时，模式与模块路径匹配。
// 使用GOPATH时，模式与对应的导入路径匹配
// 版本控制存储库的根目录。
// None
// GOVCS设置的一般形式是以逗号分隔的
// 模式：vcslist规则。该模式是必须匹配的全局模式
// 模块或导入路径的一个或多个前导元素。录像机
// 是允许的版本控制命令的管道分隔列表，或“全部”
// 允许使用任何已知命令，或“关闭”不允许使用所有命令。
// 请注意，如果模块与vcslist为“off”的模式匹配，它可能仍然是
// 如果源服务器使用“mod”方案，则下载，该方案指示
// go命令使用GOPROXY协议下载模块。
// 列表中最早的匹配模式适用，即使以后的模式也适用
// 也可能匹配。
// None
// 例如，考虑：
// None
// GOVCS=github.com:git，evil.com:off，*：git | hg
// None
// 使用此设置，可以使用以开头的模块或导入路径进行编码
// github.com/只能使用git；evil.com上的路径不能使用任何版本
// 控件命令和所有其他路径（*匹配所有内容）可以使用
// 只有吉特或汞。
// None
// “公共”和“私人”的特殊模式匹配公共和私人
// 模块或导入路径。如果路径与GOPRIVATE匹配，则该路径为private
// 变量否则它是公开的。
// None
// 如果GOVCS变量中没有与特定模块或导入路径匹配的规则，
// “go get”命令应用其默认规则，现在可以对其进行总结
// 在GOVCS中表示为“public:git | hg，private:all”。
// None
// 要允许对任何软件包自由使用任何版本控制系统，请使用：
// None
// GOVCS=*：全部
// None
// 要禁用版本控制的所有使用，请使用：
// None
// GOVCS=*：关闭
// None
// “go env-w”命令（请参阅“go help env”）可用于设置GOVCS
// 用于将来go命令调用的变量。
// None
// None
package main
